def test_yaml_files_with_backends_and_dispatch_yaml(self):
        os.path.isdir('/appdir/app.yaml').AndReturn(False)
        module_config = ModuleConfigurationStub(module_name='default')
        application_configuration.ModuleConfiguration(
            '/appdir/app.yaml', None).AndReturn(module_config)

        os.path.isdir('/appdir/backends.yaml').AndReturn(False)
        backend_config = ModuleConfigurationStub(module_name='backend')
        backends_config = self.mox.CreateMock(
            application_configuration.BackendsConfiguration)
        backends_config.get_backend_configurations().AndReturn(
            [backend_config])
        application_configuration.BackendsConfiguration(
            os.path.join('/appdir', 'app.yaml'),
            os.path.join('/appdir', 'backends.yaml'),
            None).AndReturn(backends_config)
        os.path.isdir('/appdir/dispatch.yaml').AndReturn(False)
        dispatch_config = DispatchConfigurationStub([(None, 'default'),
                                                     (None, 'backend')])
        application_configuration.DispatchConfiguration(
            '/appdir/dispatch.yaml').AndReturn(dispatch_config)

        self.mox.ReplayAll()
        config = application_configuration.ApplicationConfiguration([
            '/appdir/app.yaml', '/appdir/backends.yaml',
            '/appdir/dispatch.yaml'
        ])
        self.mox.VerifyAll()
        self.assertEqual('myapp', config.app_id)
        self.assertSequenceEqual([module_config, backend_config],
                                 config.modules)
        self.assertEqual(dispatch_config, config.dispatch)
    def test_check_for_changes(self):
        static_backend_entry = backendinfo.BackendEntry(name='static')
        dynamic_backend_entry = backendinfo.BackendEntry(name='dynamic')
        backend_info = backendinfo.BackendInfoExternal(
            backends=[static_backend_entry, dynamic_backend_entry])
        module_config = self.mox.CreateMock(
            application_configuration.ModuleConfiguration)
        self.mox.StubOutWithMock(application_configuration,
                                 'ModuleConfiguration')
        application_configuration.ModuleConfiguration(
            '/appdir/app.yaml', None).AndReturn(module_config)
        application_configuration.BackendsConfiguration._parse_configuration(
            '/appdir/backends.yaml').AndReturn(backend_info)
        module_config.check_for_updates().AndReturn(set())
        module_config.check_for_updates().AndReturn(set([1]))
        module_config.check_for_updates().AndReturn(set([2]))
        module_config.check_for_updates().AndReturn(set())

        self.mox.ReplayAll()
        config = application_configuration.BackendsConfiguration(
            '/appdir/app.yaml', '/appdir/backends.yaml')
        self.assertEqual(set(), config.check_for_updates('dynamic'))
        self.assertEqual(set([1]), config.check_for_updates('static'))
        self.assertEqual(set([1, 2]), config.check_for_updates('dynamic'))
        self.assertEqual(set([2]), config.check_for_updates('static'))
        self.mox.VerifyAll()
    def test_directory_with_backends_yaml(self):
        os.path.isdir('/appdir').AndReturn(True)
        os.path.exists(os.path.join('/appdir', 'app.yaml')).AndReturn(True)
        os.path.isdir(os.path.join('/appdir', 'app.yaml')).AndReturn(False)
        os.path.exists(os.path.join('/appdir',
                                    'backends.yaml')).AndReturn(True)
        os.path.isdir(os.path.join('/appdir',
                                   'backends.yaml')).AndReturn(False)

        module_config = ModuleConfigurationStub()
        application_configuration.ModuleConfiguration(
            os.path.join('/appdir', 'app.yaml'), None).AndReturn(module_config)
        backend_config = ModuleConfigurationStub(module_name='backend')
        backends_config = self.mox.CreateMock(
            application_configuration.BackendsConfiguration)
        backends_config.get_backend_configurations().AndReturn(
            [backend_config])
        application_configuration.BackendsConfiguration(
            os.path.join('/appdir', 'app.yaml'),
            os.path.join('/appdir', 'backends.yaml'),
            None).AndReturn(backends_config)

        self.mox.ReplayAll()
        config = application_configuration.ApplicationConfiguration(
            ['/appdir'])
        self.mox.VerifyAll()
        self.assertEqual('myapp', config.app_id)
        self.assertSequenceEqual([module_config, backend_config],
                                 config.modules)
    def test_good_configuration(self):
        self.mox.StubOutWithMock(application_configuration,
                                 'ModuleConfiguration')
        static_backend_entry = backendinfo.BackendEntry(name='static')
        dynamic_backend_entry = backendinfo.BackendEntry(name='dynamic')
        backend_info = backendinfo.BackendInfoExternal(
            backends=[static_backend_entry, dynamic_backend_entry])
        module_config = object()
        application_configuration.ModuleConfiguration(
            '/appdir/app.yaml', None).AndReturn(module_config)
        application_configuration.BackendsConfiguration._parse_configuration(
            '/appdir/backends.yaml').AndReturn(backend_info)
        static_configuration = object()
        dynamic_configuration = object()
        application_configuration.BackendConfiguration(
            module_config, mox.IgnoreArg(),
            static_backend_entry).InAnyOrder().AndReturn(static_configuration)
        application_configuration.BackendConfiguration(
            module_config, mox.IgnoreArg(),
            dynamic_backend_entry).InAnyOrder().AndReturn(
                dynamic_configuration)

        self.mox.ReplayAll()
        config = application_configuration.BackendsConfiguration(
            '/appdir/app.yaml', '/appdir/backends.yaml')
        self.assertItemsEqual([static_configuration, dynamic_configuration],
                              config.get_backend_configurations())
        self.mox.VerifyAll()
  def test_yaml_files_with_backends_and_dispatch_yaml(self):
    absnames = self._make_file_hierarchy(
        ['appdir/app.yaml', 'appdir/backends.yaml', 'appdir/dispatch.yaml'])

    module_config = ModuleConfigurationStub(module_name='default')
    application_configuration.ModuleConfiguration(
        absnames[0], None).AndReturn(module_config)

    backend_config = ModuleConfigurationStub(module_name='backend')
    backends_config = self.mox.CreateMock(
        application_configuration.BackendsConfiguration)
    backends_config.get_backend_configurations().AndReturn([backend_config])
    application_configuration.BackendsConfiguration(
        absnames[0], absnames[1], None).AndReturn(backends_config)
    dispatch_config = DispatchConfigurationStub(
        [(None, 'default'), (None, 'backend')])
    application_configuration.DispatchConfiguration(
        absnames[2]).AndReturn(dispatch_config)

    self.mox.ReplayAll()
    config = application_configuration.ApplicationConfiguration(absnames)
    self.mox.VerifyAll()
    self.assertEqual('myapp', config.app_id)
    self.assertSequenceEqual([module_config, backend_config], config.modules)
    self.assertEqual(dispatch_config, config.dispatch)
    def test_no_backends(self):
        self.mox.StubOutWithMock(application_configuration,
                                 'ModuleConfiguration')
        backend_info = backendinfo.BackendInfoExternal()
        module_config = object()
        application_configuration.ModuleConfiguration(
            '/appdir/app.yaml', None).AndReturn(module_config)
        application_configuration.BackendsConfiguration._parse_configuration(
            '/appdir/backends.yaml').AndReturn(backend_info)

        self.mox.ReplayAll()
        config = application_configuration.BackendsConfiguration(
            '/appdir/app.yaml', '/appdir/backends.yaml')
        self.assertEqual([], config.get_backend_configurations())
        self.mox.VerifyAll()
  def test_directory_with_backends_yaml(self):
    absnames = self._make_file_hierarchy(
        ['appdir/app.yaml', 'appdir/backends.yaml'])

    module_config = ModuleConfigurationStub()
    application_configuration.ModuleConfiguration(
        absnames[0], None).AndReturn(module_config)
    backend_config = ModuleConfigurationStub(module_name='backend')
    backends_config = self.mox.CreateMock(
        application_configuration.BackendsConfiguration)
    backends_config.get_backend_configurations().AndReturn([backend_config])
    application_configuration.BackendsConfiguration(
        absnames[0], absnames[1], None).AndReturn(backends_config)

    self.mox.ReplayAll()
    config = application_configuration.ApplicationConfiguration(
        [os.path.dirname(absnames[0])])
    self.mox.VerifyAll()
    self.assertEqual('myapp', config.app_id)
    self.assertSequenceEqual([module_config, backend_config], config.modules)
Beispiel #8
0
  def test_yaml_files_with_backends_yaml(self):
    os.path.isdir('/appdir/app.yaml').AndReturn(False)
    server_config = ServerConfigurationStub()
    application_configuration.ServerConfiguration(
        '/appdir/app.yaml').AndReturn(server_config)

    os.path.isdir('/appdir/backends.yaml').AndReturn(False)
    backend_config = ServerConfigurationStub(server_name='backend')
    backends_config = self.mox.CreateMock(
        application_configuration.BackendsConfiguration)
    backends_config.get_backend_configurations().AndReturn([backend_config])
    application_configuration.BackendsConfiguration(
        '/appdir/app.yaml',
        '/appdir/backends.yaml').AndReturn(backends_config)

    self.mox.ReplayAll()
    config = application_configuration.ApplicationConfiguration(
        ['/appdir/app.yaml', '/appdir/backends.yaml'])
    self.mox.VerifyAll()
    self.assertEqual('myapp', config.app_id)
    self.assertSequenceEqual([server_config, backend_config], config.servers)