Example #1
0
 def test_modes_checked(self):
     user = mock()
     user2 = mock()
     cli = self.createSshConnection(user=user)
     cli.modeList = [user, user2]
     cli.check_prereq(0)
     verify(user2).exit()
Example #2
0
 def createSshConnection(self, pexpectObject=mock(), user=mock()):
     cli = SshCli("0.0.0.0", user, pexpectObject=pexpectObject)
     cli._secure = True
     cli._connection = mock()
     user.commandLine(cli)
     cli.modeList = [user]
     return cli
 def test_ProfileUploadActionRethrowsExceptions(self):
     storage = mock()
     jsonEncoder = mock()
     action = profile.Upload(storage, **{'name': 'ProfileName', 'profile': 'p.json'})
     action.jsonEncoder = jsonEncoder
     when(jsonEncoder).encode('p.json').thenRaise(ValueError)
     self.assertRaises(ValueError, action.execute)
Example #4
0
    def test_public_exists_events(self):
        status = ServiceStatuses.BUILDING.api_status
        db_instance = DBInstance(
            InstanceTasks.BUILDING,
            created="xyz",
            name="test_name",
            id="1",
            flavor_id="flavor_1",
            compute_instance_id="compute_id_1",
            server_id="server_id_1",
            tenant_id="tenant_id_1",
            server_status=status,
        )

        server = mock(Server)
        server.user_id = "test_user_id"
        mgmt_instance = SimpleMgmtInstance(self.context, db_instance, server, None)
        when(mgmtmodels).load_mgmt_instances(self.context, deleted=False, client=self.client).thenReturn(
            [mgmt_instance, mgmt_instance]
        )
        flavor = mock(Flavor)
        flavor.name = "db.small"
        when(self.flavor_mgr).get("flavor_1").thenReturn(flavor)
        self.assertThat(self.context.auth_token, Is("some_secret_password"))
        when(notifier).notify(self.context, any(str), "trove.instance.exists", "INFO", any(dict)).thenReturn(None)
        # invocation
        mgmtmodels.publish_exist_events(NovaNotificationTransformer(context=self.context), self.context)
        # assertion
        verify(notifier, times=2).notify(self.context, any(str), "trove.instance.exists", "INFO", any(dict))
        self.assertThat(self.context.auth_token, Is(None))
Example #5
0
    def setup(self):
        """
        Setup the test case
        """
        self.rng = Random()
        self.model = mock()
        self.effect_factory = mock()

        drink_factory = DrinkFactory(self.effect_factory)
        self.action_factory = ActionFactory(self.model,
                                            drink_factory)

        self.character = (CharacterBuilder()
                            .with_action_factory(self.action_factory)
                            .with_hit_points(1)
                            .with_max_hp(5)
                            .build())

        effect = Heal(duration = 0,
                      frequency = 0,
                      tick = 0,
                      healing = 5,
                      target = self.character)
        when(self.effect_factory).create_effect(any(),
                                                target = any()).thenReturn(effect)

        self.potion = (ItemBuilder()
                            .with_name('healing potion')
                            .with_effect(
                                EffectHandleBuilder()
                                    .with_trigger('on drink')
                                    .with_effect('heal'))
                            .build())

        self.character.inventory.append(self.potion)
Example #6
0
    def setUp(self):
        super(FreshInstanceTasksTest, self).setUp()

        when(taskmanager_models.FreshInstanceTasks).id().thenReturn(
            "instance_id")
        when(taskmanager_models.FreshInstanceTasks).tenant_id().thenReturn(
            "tenant_id")
        when(taskmanager_models.FreshInstanceTasks).hostname().thenReturn(
            "hostname")
        when(taskmanager_models.FreshInstanceTasks).name().thenReturn(
            'name')
        when(datastore_models.
             DatastoreVersion).load(any()).thenReturn(mock())
        when(datastore_models.
             Datastore).load(any()).thenReturn(mock())
        taskmanager_models.FreshInstanceTasks.nova_client = fake_nova_client()
        taskmanager_models.CONF = mock()
        when(taskmanager_models.CONF).get(any()).thenReturn('')
        self.orig_ISS_find_by = InstanceServiceStatus.find_by
        self.orig_DBI_find_by = DBInstance.find_by
        self.userdata = "hello moto"
        self.guestconfig_content = "guest config"
        with NamedTemporaryFile(suffix=".cloudinit", delete=False) as f:
            self.cloudinit = f.name
            f.write(self.userdata)
        with NamedTemporaryFile(delete=False) as f:
            self.guestconfig = f.name
            f.write(self.guestconfig_content)
        self.freshinstancetasks = taskmanager_models.FreshInstanceTasks(
            None, mock(), None, None)
Example #7
0
    def test_image_name(self):
        res = mock(requests.Response)
        url = 'https://example.com/scheduler/jobs/search?name=example_team-app'
        image_data = [{'container':{'image':'place-robot-simpleapp-2345643lkjfkdajurakdsfoweifa/v0.1.0'}}]
        data = {'environments':{'dev':{'chronos_endpoint':'https://example.com'}}}
        os.environ['ROGER_CONFIG_DIR'] = '/vagrant/config'
        username = '******'
        password = '******'
        config_dir = '/vagrant/config'
        config_file = 'test.yml'

        app_config_object = mock(AppConfig)
        when(app_config_object).getRogerEnv(config_dir).thenReturn(data)
        when(requests).get(url, auth=(username, password)).thenReturn(res)
        when(res).json().thenReturn(image_data)

        c = Chronos()
        img = c.get_image_name(
            username,
            password,
            'dev',
            'example_team-app',
            config_dir,
            config_file,
            app_config_object
        )
        assert img == image_data[0]['container']['image']
    def test_should_return_empty_running_environment_if_nothing_is_running(self):
        fake_boto_instance = mock()

        tags = {
            'services' : """
                apache :
                80: 80""",
            'credentials_name': 'test',
            'env_name' : 'my_environment',
            'env_def_name' : 'Single-AZ Deployment',
            }
        fake_boto_instance.tags = tags
        stub_region = mock()
        stub_region.name = 'eu-west'
        fake_boto_instance.region = stub_region
        fake_boto_instance.image_id = '1234'
        fake_boto_instance.instance_type = 'large'

        mock_connection_provider = mock()
        when(mock_connection_provider).ec2_connection_for_region("eu-west", None, None).thenReturn(None)
        when(mock_connection_provider).get_all_boto_instances(None, None).thenReturn([fake_boto_instance])

        provider = AWSNodeProvider(None, None, mock_connection_provider)

        environment = provider.get_running_environment("test","test", all_credentials)
        self.assertIsNotNone(environment)
        self.assertEqual(0, len(environment.get_locations()))
Example #9
0
    def test_register_should_call_listener_for_each_late_combination_of_references_when_there_are_multiple_selectors(self):
        reference1a = 'REFERENCE1a'
        reference2a = 'REFERENCE2a'
        reference1b = 'REFERENCE1b'
        reference2b = 'REFERENCE2b'

        selection_a = mock()
        (when(selection_a).__iter__()
            .thenReturn([reference1a].__iter__())
            .thenReturn([reference1a, reference2a].__iter__())
            .thenReturn([reference1a, reference2a].__iter__()))
        when(selection_a).is_elegible(reference2a).thenReturn(True)

        selection_b = mock()
        (when(selection_b).__iter__()
            .thenReturn([reference1b].__iter__())
            .thenReturn([reference1b].__iter__())
            .thenReturn([reference1b, reference2b].__iter__()))
        when(selection_b).is_elegible(reference2b).thenReturn(True)

        self.manager.register(self.listener_callable_mock, utils.IterableMock(selection_a), utils.IterableMock(selection_b))
        verify(self.listener_mock, times=1).__call__(reference1a, reference1b)
        verifyNoMoreInteractions(self.listener_mock)

        self.manager.evaluate_new_candidate(reference2a)
        verify(self.listener_mock, times=1).__call__(reference2a, reference1b)
        verifyNoMoreInteractions(self.listener_mock)

        self.manager.evaluate_new_candidate(reference2b)
        verify(self.listener_mock, times=1).__call__(reference1a, reference2b)
        verify(self.listener_mock, times=1).__call__(reference2a, reference2b)
        verifyNoMoreInteractions(self.listener_mock)
Example #10
0
    def setup(self):
        """
        Setup the test case
        """
        model = mock()
        action_factory = mock()
        rng = mock()

        self.creature1 = (CharacterBuilder()
                            .with_tick(5)
                            .with_speed(1)
                            .with_name('creature 1')
                            .build())

        self.creature2 = (CharacterBuilder()
                            .with_tick(0)
                            .with_speed(2)
                            .with_name('creature 2')
                            .build())

        self.creature3 = (CharacterBuilder()
                            .with_tick(3)
                            .with_speed(0.5)
                            .with_name('creature 3')
                            .build())

        self.model = Model()
        self.model.dungeon = Dungeon()
        self.model.dungeon.levels = Level((20, 20), 0, 0)

        self.model.dungeon.levels.add_creature(self.creature1)
        self.model.dungeon.levels.add_creature(self.creature2)
        self.model.player = self.creature3
        self.model.dungeon.levels.add_creature(self.creature3)
 def test_find_by_name_parent_is_webelement(self):
     webelement = mock()
     when(self.finder)._is_webelement(webelement).thenReturn(True)
     when(self.finder)._is_webelement('name=value').thenReturn(False)
     when(webelement).find_elements_by_name('value').thenReturn([mock()])
     self.finder.find('name=value', parent=webelement)
     verify(webelement).find_elements_by_name("value")
 def test_find_by_xpath_parent_is_webelement(self):
     webelement = mock()
     when(self.finder)._is_webelement(webelement).thenReturn(True)
     when(self.finder)._is_webelement('//div').thenReturn(False)
     when(webelement).find_elements_by_xpath('//div').thenReturn([mock()])
     self.finder.find('//div', parent=webelement)
     verify(webelement).find_elements_by_xpath('//div')
Example #13
0
    def test_dual_wielding(self):
        """
        Test that character can wield two weapons
        """
        item1 = (ItemBuilder()
                        .with_name('dagger')
                        .with_tag('light weapon')
                        .with_damage(1)
                        .build())

        item2 = (ItemBuilder()
                        .with_name('sickle')
                        .with_tag('light weapon')
                        .with_damage(2)
                        .build())

        assert_that(item1, is_not(is_in(self.character.weapons)))
        assert_that(item2, is_not(is_in(self.character.weapons)))

        pyherc.rules.items.wield(mock(), self.character, item1)
        pyherc.rules.items.wield(mock(),
                                 self.character,
                                 item2,
                                 dual_wield = True)

        assert_that(item1, is_in(self.character.weapons))
        assert_that(item2, is_in(self.character.weapons))
Example #14
0
    def test_tranformer_shutdown_instance(self):
        status = rd_instance.ServiceStatuses.SHUTDOWN.api_status
        db_instance = self.build_db_instance(status)

        server = mock(Server)
        server.user_id = 'test_user_id'
        mgmt_instance = mgmtmodels.SimpleMgmtInstance(self.context,
                                                      db_instance,
                                                      server,
                                                      None)
        when(Backup).running('1').thenReturn(None)
        self.assertThat(mgmt_instance.status, Equals('SHUTDOWN'))
        when(mgmtmodels).load_mgmt_instances(
            self.context,
            deleted=False,
            client=self.client).thenReturn(
                [mgmt_instance])
        flavor = mock(Flavor)
        flavor.name = 'db.small'
        when(self.flavor_mgr).get('flavor_1').thenReturn(flavor)
        # invocation
        transformer = mgmtmodels.NovaNotificationTransformer(
            context=self.context)
        payloads = transformer()
        # assertion that SHUTDOWN instances are not reported
        self.assertIsNotNone(payloads)
        self.assertThat(len(payloads), Equals(0))
Example #15
0
	def setUp(self):
		self.transaction = mock()
		self.transaction._map = {}
		self.cursor = mock()
		self.connection = mock()
		self.transaction.cursor = self.cursor
		when(self.cursor).getconnection().thenReturn(self.connection)
Example #16
0
    def test_tranformer_flavor_cache(self):
        status = rd_instance.ServiceStatuses.BUILDING.api_status
        db_instance = MockMgmtInstanceTest.build_db_instance(
            status, InstanceTasks.BUILDING)

        server = mock(Server)
        server.user_id = 'test_user_id'
        mgmt_instance = mgmtmodels.SimpleMgmtInstance(self.context,
                                                      db_instance,
                                                      server,
                                                      None)
        when(mgmtmodels).load_mgmt_instances(
            self.context,
            deleted=False,
            client=self.client).thenReturn(
                [mgmt_instance])
        flavor = mock(Flavor)
        flavor.name = 'db.small'
        when(self.flavor_mgr).get('flavor_1').thenReturn(flavor)
        transformer = mgmtmodels.NovaNotificationTransformer(
            context=self.context)
        transformer()
        # call twice ensure client.flavor invoked once
        payloads = transformer()
        self.assertIsNotNone(payloads)
        self.assertThat(len(payloads), Equals(1))
        payload = payloads[0]
        self.assertThat(payload['audit_period_beginning'], Not(Is(None)))
        self.assertThat(payload['audit_period_ending'], Not(Is(None)))
        self.assertThat(payload['state'], Equals(status.lower()))
        self.assertThat(payload['instance_type'], Equals('db.small'))
        self.assertThat(payload['instance_type_id'], Equals('flavor_1'))
        self.assertThat(payload['user_id'], Equals('test_user_id'))
        # ensure cache was used to get flavor second time
        verify(self.flavor_mgr).get('flavor_1')
 def make_edge_with_mock_vehicles(self):
     edge, lane_1, lane_2 = self.make_edge_without_vehicles()
     first = mock()
     second = mock()
     lane_1.add_vehicle(first)
     lane_2.add_vehicle(second)
     return edge, first, second
    def test_should_throw_exception_when_node_is_not_up_and_running(self):
        mock_connection_provider = mock()
        tags = {
            'services' : """
                'apache' :
                     80: 80""",
            'credentials_name': 'test',
            'env_name' : 'test',
            'env_def_name' : 'Single-AZ Deployment',
            }
        fake_boto_instance1 = mock()
        fake_boto_instance1.tags = tags
        stub_region = mock()
        stub_region.name = 'eu-west'
        fake_boto_instance1.region = stub_region
        fake_boto_instance1.id = 'id1234'
        fake_boto_instance1.ip_address = 'test_ip'
        fake_boto_instance1.state = 'running'
        fake_boto_instance1.placement='us-east-1'
        aws_node = AWSRunningNode(fake_boto_instance1, None, mock_connection_provider)

        when(mock_connection_provider).connected_to_node('test_ip', 22).thenReturn(False)

        with self.assertRaisesRegexp(Exception, "Node id1234 is not running"):
            aws_node.wait_for_ready(lambda : None, 5)
Example #19
0
def mock_sql_connection():
    mock_engine = mock()
    when(sqlalchemy).create_engine("mysql://root:@localhost:3306", echo=True).thenReturn(mock_engine)
    mock_conn = mock()
    when(dbaas.LocalSqlClient).__enter__().thenReturn(mock_conn)
    when(dbaas.LocalSqlClient).__exit__(any(), any(), any()).thenReturn(None)
    return mock_conn
Example #20
0
    def test_create_incremental(self):
        instance = mock(instance_models.Instance)
        parent = mock(models.DBBackup)
        when(instance_models.BuiltInstance).load(any(), any()).thenReturn(
            instance)
        when(instance).validate_can_perform_action().thenReturn(None)
        when(models.Backup).verify_swift_auth_token(any()).thenReturn(
            None)
        when(api.API).create_backup(any()).thenReturn(None)
        when(models.Backup).get_by_id(any(), any()).thenReturn(
            parent)

        incremental = models.Backup.create(self.context, self.instance_id,
                                           BACKUP_NAME, BACKUP_DESC,
                                           parent_id='parent_uuid')

        self.created = True

        db_record = models.DBBackup.find_by(id=incremental.id)
        self.assertEqual(incremental.id, db_record['id'])
        self.assertEqual(BACKUP_NAME, db_record['name'])
        self.assertEqual(BACKUP_DESC, db_record['description'])
        self.assertEqual(self.instance_id, db_record['instance_id'])
        self.assertEqual(models.BackupState.NEW, db_record['state'])
        self.assertEqual('parent_uuid', db_record['parent_id'])
    def test_search_found_multiple(self):  # pylint: disable=too-many-locals
        """Test found multiple colors."""
        begin = 5
        end = 15
        region = NormalizedRegion(begin, end)
        whole_region = mock()
        when(sublime).Region(begin, end).thenReturn(whole_region)
        color_region1 = mock()
        when(sublime).Region(begin + 1, begin + 4).thenReturn(color_region1)
        color_region2 = mock()
        when(sublime).Region(end - 4, end - 1).thenReturn(color_region2)
        view = mock()
        test_color_text1 = "#FA"
        test_color_text2 = "#E5"
        when(view).substr(whole_region).thenReturn(" %s  %s " % (test_color_text1, test_color_text2))
        when(view).substr(color_region1).thenReturn(test_color_text1)
        when(view).substr(color_region2).thenReturn(test_color_text2)
        test_color1 = "#FB"
        test_color2 = "#DB"
        test_group = "test_group"
        color_converter = mock()
        when(color_converter).to_color({test_group: test_color_text1}).thenReturn(test_color1)
        when(color_converter).to_color({test_group: test_color_text2}).thenReturn(test_color2)
        color_searcher = ColorSearcher(re.compile("(?P<%s>#[0-9a-fA-F]{2})" % test_group), color_converter)

        results = [result for result in color_searcher.search(view, region)]
        self.assertEqual(
            [(NormalizedRegion(begin + 1, begin + 4), test_color1, {test_group: test_color_text1}),
             (NormalizedRegion(end - 4, end - 1), test_color2, {test_group: test_color_text2})], results)
    def test_roger_push_env_from_ROGER_ENV_VAR(self):
        settings = mock(Settings)
        appConfig = mock(AppConfig)
        roger_push = RogerPush()
        marathon = mock(Marathon)
        mockedHooks = mock(Hooks)
        roger_env = self.roger_env
        config = self.config
        frameworkUtils = mock(FrameworkUtils)
        when(settings).getConfigDir().thenReturn(self.configs_dir)
        when(mockedHooks).run_hook(any(), any(), any()).thenReturn(0)
        when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env)
        when(appConfig).getConfig(any(), any()).thenReturn(config)

        args = self.args
        args.env = None
        args.secrets_file = ""
        args.skip_push = True
        args.app_name = 'grafana_test_app'
        args.config_file = 'test.json'

        roger_env = appConfig.getRogerEnv(self.configs_dir)
        roger_env["default_environment"] = None
        # Setting ROGER_ENV to specific value
        os.environ["ROGER_ENV"] = "test_env"

        with self.assertRaises(ValueError):
            roger_push.main(settings, appConfig,
                            frameworkUtils, mockedHooks, args)
Example #23
0
    def test_processingtask_factory_should_return_processing_task(self):
        instance = mock()
        dependencies = mock()
        registration = mock()

        result = task.factory(instance, registration, dependencies)
        assert isinstance(result, task.DataFrameDatasourceTask)
Example #24
0
    def test_tranformer_shutdown_instance(self):
        status = ServiceStatuses.SHUTDOWN.api_status
        db_instance = DBInstance(InstanceTasks.DELETING,
                                 created='xyz',
                                 name='test_name',
                                 id='1',
                                 flavor_id='flavor_1',
                                 compute_instance_id='compute_id_1',
                                 server_id='server_id_1',
                                 tenant_id='tenant_id_1',
                                 server_status=status)

        server = mock(Server)
        server.user_id = 'test_user_id'
        mgmt_instance = SimpleMgmtInstance(self.context,
                                           db_instance,
                                           server,
                                           None)
        when(Backup).running('1').thenReturn(None)
        self.assertThat(mgmt_instance.status, Equals('SHUTDOWN'))
        when(mgmtmodels).load_mgmt_instances(
            self.context,
            deleted=False,
            client=self.client).thenReturn(
                [mgmt_instance])
        flavor = mock(Flavor)
        flavor.name = 'db.small'
        when(self.flavor_mgr).get('flavor_1').thenReturn(flavor)
        # invocation
        transformer = NovaNotificationTransformer(context=self.context)
        payloads = transformer()
        # assertion that SHUTDOWN instances are not reported
        self.assertIsNotNone(payloads)
        self.assertThat(len(payloads), Equals(0))
Example #25
0
    def test_process_should_receive_dependencies_process_results_as_context(self):
        registration = mock()

        symbol = 'symbol'
        start = None
        end = None

        expected_a = pandas.DataFrame([1, 2, 3])
        expected_b = pandas.DataFrame([9, 8, 7])

        class DatasourceMock():

            def evaluate(self, context, s, ds, de):
                assert isinstance(context, task.DatasourceContext)
                deps = context.dependencies()
                assert isinstance(deps, dict)
                assert len(deps) is 2
                assert (deps['a'].values == expected_a.values).all()
                assert (deps['b'].values == expected_b.values).all()
                assert s == symbol
                assert ds == start
                assert de == end

        dependencies = {
            'a': mock(task.DataFrameDatasourceTask),
            'b': mock(task.DataFrameDatasourceTask),
        }
        when(dependencies['a']).process(symbol, start, end).thenReturn(expected_a)
        when(dependencies['b']).process(symbol, start, end).thenReturn(expected_b)

        task.DataFrameDatasourceTask(DatasourceMock(), registration, dependencies).process(symbol, start, end)
Example #26
0
    def test_should_execute_test_function_when_running_test(self):
        test_definition_mock = mock(TestDefinition)
        when(self.injector_mock).execute_test(test_definition_mock).thenReturn(mock(TestResult))

        self.test_runner.run_test([test_definition_mock])

        when(self.injector_mock).execute_test(test_definition_mock)
    def start_client(self):
        soledad_test_folder = self._generate_soledad_test_folder_name()
        SearchEngine.DEFAULT_INDEX_HOME = soledad_test_folder

        self.cleanup = lambda: shutil.rmtree(soledad_test_folder)

        self.soledad = yield initialize_soledad(tempdir=soledad_test_folder)

        self.keymanager = mock()

        self.search_engine = SearchEngine(self.INDEX_KEY, agent_home=soledad_test_folder)
        self.mail_sender = self._create_mail_sender()

        self.mail_store = SearchableMailStore(LeapMailStore(self.soledad), self.search_engine)

        account_ready_cb = defer.Deferred()
        self.account = IMAPAccount(self.ACCOUNT, self.soledad, account_ready_cb)
        yield account_ready_cb
        self.draft_service = DraftService(self.mail_store)
        self.leap_session = mock()
        self.feedback_service = FeedbackService(self.leap_session)

        self.mail_service = self._create_mail_service(self.mail_sender, self.mail_store, self.search_engine)
        mails = yield self.mail_service.all_mails()
        self.search_engine.index_mails(mails)

        self.resource = RootResource()
        self.resource.initialize(
            self.keymanager, self.search_engine, self.mail_service, self.draft_service, self.feedback_service
        )
Example #28
0
    def test_level_generator_is_created(self):
        """
        Test that portal adder has level generator set to it
        """
        portal_config = [PortalAdderConfiguration(icons = (1, 2),
                                                  level_type = 'catacombs',
                                                  location_type = 'room',
                                                  chance = 100,
                                                  new_level = 'upper crypt',
                                                  unique = False)]

        level_generator_factory = mock(LevelGeneratorFactory)
        level_generator = mock(LevelGenerator)

        when(level_generator_factory).get_generator(any()).thenReturn(level_generator)

        factory = PortalAdderFactory(portal_config,
                                     self.rng)
        factory.level_generator_factory = level_generator_factory

        portal_adders = factory.create_portal_adders('catacombs')

        portal_adder = portal_adders[0]

        assert_that(portal_adder.level_generator,
                    is_(same_instance(level_generator)))
Example #29
0
    def test_dual_wielding_two_handed_weapons(self): #pylint: disable=C0103
        """
        Test that character can not dual wield two-handed weapon
        """
        item1 = (ItemBuilder()
                        .with_name('longspear')
                        .with_tag('two-handed weapon')
                        .with_tag('weapon')
                        .build())

        item2 = (ItemBuilder()
                        .with_name('sickle')
                        .with_tag('light weapon')
                        .with_tag('weapon')
                        .build())

        assert_that(item1, is_not(is_in(self.character.weapons)))
        assert_that(item2, is_not(is_in(self.character.weapons)))

        pyherc.rules.items.wield(mock(), self.character, item2)
        pyherc.rules.items.wield(mock(), self.character,
                                 item1,
                                 dual_wield = True)

        assert_that(item1, is_not(is_in(self.character.weapons)))
        assert_that(item2, is_in(self.character.weapons))
Example #30
0
    def __init__(self):
        """
        Default constructor
        """
        super(CharacterBuilder, self).__init__()
        self.hit_points = 10
        self.max_hp = 10
        self.model = mock()
        self.action_factory = mock()
        self.rng = Random()

        self.speed = 1
        self.tick = 0
        self.attack = 1
        self.body = 1
        self.mind = 1

        self.name = 'prototype'

        self.level = None
        self.location = ()

        self.effect_handles = []
        self.effects = []
        self.effects_collection = EffectsCollection()
        self.player_character = False

        self.listeners = []
Example #31
0
    def testShouldScreamWhenCallingUnexpectedMethod(self):
        action = mock(Action)

        with pytest.raises(AttributeError):
            action.run(11)
Example #32
0
    def testShouldScreamWhenCallingUnknownMethod(self):
        action = mock(Action)

        with pytest.raises(AttributeError):
            action.unknownMethod()
 def testWithConflictingNames(self):
     theMock = mock(IWithGet)
     when(theMock).get('d').thenReturn(0)
     when(theMock).names().thenReturn(0)
Example #34
0
 def root_chain(self):
     root_chain = mock()
     root_chain.functions = mock()
     return root_chain
def mock_file_detector(creator):
    file_detector = mock()
    when(creator)._get_sl_file_detector().thenReturn(file_detector)
    return file_detector
Example #36
0
    def testShouldPassIsInstanceChecks(self):
        action = mock(Action)

        assert isinstance(action, Action)
Example #37
0
    def testPreconfigureWithFunctionThatTakesNoArgs(self):
        action = mock({'no_arg': lambda: 12}, spec=Action)

        assert action.no_arg() == 12

        verify(action).no_arg()
Example #38
0
 def get_db(*args):
     db_mock = mockito.mock(Database)
     mockito.when(db_mock).documents().thenReturn([])
     return db_mock
def finder():
    ctx = mock()
    ctx.driver = mock()
    return ElementFinder(ctx)
 def setUp(self):
     ctx = mock()
     ctx.event_firing_webdriver = None
     ctx._browser = mock()
     ctx._drivers = mock()
     self.brorser = BrowserManagementKeywords(ctx)
Example #41
0
 def setUp(self):
     self.ctx = mock()
     self.ctx.driver = self.driver = mock()
     self.finder = ExtendedElementFinder(self.ctx)
Example #42
0
 def create_file_operator_mock(self):
     self.file_operator_mock = mock()
     when(self.file_operator_mock).get_all_files_under(any(str)).thenReturn([])
     when(self.file_operator_mock).exists(any(str)).thenReturn(False)
     when(self.file_operator_mock).getsize(any(str)).thenReturn(0)
Example #43
0
def box_api_mocker(uri):
    response = mock({'status_code': 200, 'text': 'Ok'})
    when(requests).get(uri).thenReturn(response)
    requests.get(uri)
    unstub()
Example #44
0
    def testPreconfigureMockWithAttributes(self):
        action = mock({'foo': 'bar'}, spec=Action)

        assert action.foo == 'bar'
        with pytest.raises(InvocationError):
            when(action).remember()
Example #45
0
    def testPreconfigureWithFunction(self):
        action = mock({'run': lambda _: 12}, spec=Action)

        assert action.run(11) == 12

        verify(action).run(11)
Example #46
0
# -*- coding:utf-8 -*-
import unittest
from mockito import when, mock, unstub, verify,times

import test_data
import simplejson as sjson

from util import log_utils


import  datetime
from core import database
from cache import  rediscache
when(database).db_session().thenReturn(mock())
from cache import api_mongo
from cache.api_mongo import  ApiMongo
# from cache.api_rcms import ApiRCMS
# from cache.api_portal import ApiPortal

class ApiMongoTest(unittest.TestCase):
    def setUp(self):
        api_mongo.ApiRCMS=mock()
        api_mongo.ApiPortal=mock()
        api_mongo.rediscache=mock()
        # self.ApiRCMS=mock()
        # self.ApiPortal=mock()
        dbsession=mock()
        dbsession.statistical=mock()
        when(database).db_session().thenReturn(dbsession)
        dbsession.cache_user_channels=mock()
        when(dbsession.cache_user_channels).create_index('username').thenReturn('username')
Example #47
0
    def testShouldScreamOnUnknownAttribute(self):
        action = mock(Action)

        with pytest.raises(AttributeError):
            action.cam
Example #48
0
    def testHasANiceName(self):
        action = mock(Action)

        assert repr(action) == "<DummyAction id=%s>" % id(action)
 def _execute_rename_resource(self, new_basename, boolean_variable):
     self.res_controller.remove_from_filesystem = mock()
     self.res_controller.save = mock()
     self.res_controller.execute(RenameResourceFile(new_basename, lambda : boolean_variable))
Example #50
0
 def testFails(self):
     theMock = mock()
     theMock.foo()
     self.assertRaises(VerificationError, verifyNoMoreInteractions, theMock)
Example #51
0
 def testPrintsNicely(self):
   theMock = mock()
   try:
     verify(theMock).foo()
   except VerificationError, e:
     self.assertEquals("\nWanted but not invoked: foo()", str(e))
Example #52
0
 def testVerifies(self):
     theMock = mock()
     verifyZeroInteractions(theMock)
     theMock.foo()
     self.assertRaises(VerificationError, verifyNoMoreInteractions, theMock)
 def testInheritedInterface(self):
     theMock = mock(ISuper)
     when(theMock).simple('a', 'b', 'c').thenReturn(0)
     when(theMock).complex('d').thenReturn(0)
Example #54
0
 def setUp(self):
     self.mock = mock()
Example #55
0
 def testReturnNoneForEveryMethod(self):
     action = mock(Action, strict=False)
     assert action.unknownMethod() is None
     assert action.run(11) is None
 def testNamedParam(self):
     theMock = mock(ITest)
     when(theMock).simple_with_names_params('d', 'e', any(),
                                            d=1).thenReturn(0)
Example #57
0
    def testStubCallAndVerify(self):
        action = mock(Action)

        when(action).run(11).thenReturn(12)
        assert action.run(11) == 12
        verify(action).run(11)
Example #58
0
    def testShouldScreamWhenStubbingUnknownMethod(self):
        action = mock(Action)

        with pytest.raises(InvocationError):
            when(action).unknownMethod()
Example #59
0
 def child_chain(self):
     return mock()
Example #60
0
 def setUp(self):
     self._mappers_manager = managers.mapper_manager.MapperManager()
     self._persistence_manager = NullPersistenceManager()
     self._mappers_manager.createMappers(self._persistence_manager)
     self.model_controller = model.controller.ModelController(
         mock(), self._mappers_manager)