def can_update(self): model = TestModel() model.thing = 'bam' model.update(thing='other') expect(model.thing).to.equal('other')
def transmute_to_with_different_attr_naming(self): model = TestDifferentAttrNaming() model.my_thing = 'something' result = JsonTransmuter.transmute_to(model, to_string=False) expect(result['my-thing']).to.equal('something')
def cannot_be_instantiated(self): try: result = AbstractPlugin() except TypeError: # Expected result = None expect(result).to.be_none()
def transmute_to_and_from_with_expanded_type(self): class CustomType(object): def __init__(self, something): self.something = something class CustomDefinition(ExpandedType): cls = CustomType @classmethod def serialize(self, value): return {'something': value.something} @classmethod def deserialize(self, attr_type, value): return attr_type(**value) class TestMappedModel(JsonMappedModel): __mapping__ = { 'test': Attr('test', CustomType), } model = TestMappedModel() model.test = CustomType('thing') serialized = '{"test": {"something": "thing"}}' alchemize.register_type(CustomDefinition) result = JsonTransmuter.transmute_to(model) expect(result).to.equal(serialized) result = JsonTransmuter.transmute_from(serialized, TestMappedModel) expect(result.test.something).to.equal('thing') alchemize.remove_type(CustomDefinition)
def transmute_to_and_from_with_excluded_items(self): class MixedMappedModel(JsonMappedModel): __mapping__ = { 'test': Attr('test', int), 'another': Attr('another', int, serialize=False) } mapping = MixedMappedModel() mapping.test = 1 mapping.another = 2 without_result = '{"test": 1}' result_without = JsonTransmuter.transmute_to(mapping) expect(result_without).to.equal(without_result) # Make sure we can override the serialization preferences result_with = JsonTransmuter.transmute_to(mapping, to_string=False, serialize_all=True) expect(result_with.get('test')).to.equal(1) expect(result_with.get('another')).to.equal(2) result = JsonTransmuter.transmute_from({ 'test': 100, 'another': 200 }, MixedMappedModel) expect(result.test).to.equal(100) expect(result.another).to.equal(200)
def transmute_from_with_inherited_mapping(self): data = '{"test": "sample", "second": "other"}' result = JsonTransmuter.transmute_from(data, TestExtendedModel) expect(result.test).to.equal('sample') expect(result.second).to.equal('other')
def transmute_from_with_child_mapping(self): data = '{"other": "sample", "child": {"test": "sample stuff"}}' result = JsonTransmuter.transmute_from(data, TestChildMapping) require(result.child).not_to.be_none() expect(result.child.test).to.equal('sample stuff')
def can_authenticate(self, post_func): post_func.return_value = get_keystone_v2_auth_resp() creds = self.auth.authenticate() expect(creds.get('token', None)).to.equal('some_token') expect(creds.get('project_id', None)).to.equal('some_tenant')
def transmute_to_and_from_with_custom_serializer(self): mapping = TestWrappedModel() mapping.test = "bam" json_str = '{"#item": {"test": "bam"}}' class Custom(object): @classmethod def dumps(cls, value): value['#item']['test'] = 'allthethings' return json.dumps(value) @classmethod def loads(cls, value): loaded = json.loads(json_str) loaded['#item']['test'] = 'magic' return loaded result = JsonTransmuter.transmute_to(mapping, encoder=Custom) expect(result).to.equal('{"#item": {"test": "allthethings"}}') result = JsonTransmuter.transmute_from(json_str, TestWrappedModel, decoder=Custom) expect(result.test).to.equal('magic')
def transmute_to_with_empty_submodel(self): model = TestChildMapping() model.child = None result = JsonTransmuter.transmute_to(model, to_string=False) expect(result.get('child')).to.be_none()
def can_use_yaml_cfg_with_handler_override(self): with mock_ssm(): options = { 'PARAMETER_STORE_AWS_REGION': 'us-west-2', 'PARAMETER_STORE_PREFIX': '/aumbry-test', } expected_cfg = SampleYamlConfig() expected_cfg.nope = 'testing' handler = GenericHandler() # Save Sample Config aumbry.save(aumbry.PARAM_STORE, expected_cfg, options, handler=handler) # Retrieve back the config cfg = aumbry.load(aumbry.PARAM_STORE, SampleGenericConfig, options, handler=handler) expect(cfg.nope).to.equal(expected_cfg.nope)
def can_convert_to_dictionary(self): tmp_uuid = str(uuid.uuid4()) tenant = Tenant(name=tmp_uuid, tenant_id=tmp_uuid) tenant_dict = tenant.as_dict() test_dict = Tenant.build_tenant_from_dict(tenant_dict).as_dict() expect(tenant_dict).to.equal(test_dict)
def should_take_into_account_conditional_probability(self): user_tz = ['Eastern (US & Canada)', 'Pacific (US & Canada)'] l1_time = [9, 9] l1_day = [0, 1] l2_time = [9, 9] l2_day = [3, 4] l3_time = [None, 9] l3_day = [None, 5] schedule_type = [2, 3] training_data = pd.DataFrame({ 'user_tz': user_tz, 'l1_time': l1_time, 'l1_day': l1_day, 'l2_time': l2_time, 'l2_day': l2_day, 'l3_time': l3_time, 'l3_day': l3_day, 'schedule_type': schedule_type }) business_forecast = [{'schedule_type': 2, 'user_tz': 'Eastern (US & Canada)', 'frequency': 1 }, {'schedule_type': 3, 'user_tz': 'Pacific (US & Canada)', 'frequency': 2 }] model = GeneralProbModel() model.fit(training_data) p = model.predict(business_forecast) expect(True).to.equal(True)
def can_load(self, raw, cls): temp, options = write_temp_file(raw) cfg = aumbry.load(aumbry.FILE, cls, options) os.remove(temp.name) expect(cfg.nope).to.equal('testing')
def transmute_to_and_from_with_custom_serializer(self): mapping = TestWrappedModel() mapping.test = "bam" json_str = '{"#item": {"test": "bam"}}' class Custom(object): @classmethod def dumps(cls, value): value['#item']['test'] = 'allthethings' return json.dumps(value) @classmethod def loads(cls, value): loaded = json.loads(json_str) loaded['#item']['test'] = 'magic' return loaded result = JsonTransmuter.transmute_to( mapping, encoder=Custom ) expect(result).to.equal('{"#item": {"test": "allthethings"}}') result = JsonTransmuter.transmute_from( json_str, TestWrappedModel, decoder=Custom ) expect(result.test).to.equal('magic')
def should_not_have_weird_hours(self): user_tz = ['Eastern (US & Canada)', 'Pacific (US & Canada)'] l1_time = [9, 9] l2_time = [9, 9] l3_time = [None, 9] training_data = pd.DataFrame({ 'user_tz': user_tz, 'l1_time': l1_time, 'l2_time': l2_time }) business_forecast = [{ 'schedule_type': 2, 'timezone': 'Eastern (US & Canada)', 'frequency': 1 }, { 'schedule_type': 3, 'timezone': 'Pacific (US & Canada)', 'frequency': 2 }] smart_heuristic_model = SmartHeuristicModel() smart_heuristic_model.fit(training_data) schedule = smart_heuristic_model.\ generate_sample_schedule(business_forecast) _sum = schedule._table_df.sum().sum() expect(_sum).to.equal(8)
def handles_predicting_cases_it_has_not_seen_before(self): user_tz = ['Eastern (US & Canada)', 'Pacific (US & Canada)'] l1_time = [9, 9] l1_day = [0, 1] l2_time = [9, 9] l2_day = [3, 4] l3_time = [None, 9] l3_day = [None, 5] schedule_type = [2, 3] training_data = pd.DataFrame({ 'user_tz': user_tz, 'l1_time': l1_time, 'l1_day': l1_day, 'l2_time': l2_time, 'l2_day': l2_day, 'l3_time': l3_time, 'l3_day': l3_day, 'schedule_type': schedule_type }) business_forecast = [{'schedule_type': 1, 'user_tz': 'Eastern (US & Canada)', 'frequency': 1 }, {'schedule_type': 4, 'user_tz': 'Pacific (US & Canada)', 'frequency': 2 }] model = GeneralProbModel() model.fit(training_data) p = model.predict(business_forecast) expect(True).to.equal(True)
def can_delete_job(self): post_resp = self._post_job() job_id = post_resp.json['job_id'] resp = self.app.delete('/v1/tenant/jobs/{0}'.format(job_id), expect_errors=True) expect(resp.status_int).to.equal(200)
def transmute_to_and_from_with_unknown_type(self): class CustomType(object): def __init__(self, something): self.something = something class TestMappedModel(JsonMappedModel): __mapping__ = { 'test': Attr('test', CustomType), } model = TestMappedModel() model.test = CustomType('thing') serialized = '{}' result = JsonTransmuter.transmute_to(model) expect(result).to.equal(serialized) result = JsonTransmuter.transmute_from( '{"test": {"something": "thing"}}', TestMappedModel ) attr = getattr(result, 'test', None) expect(attr).to.be_none()
def transmute_to_and_from_with_excluded_items(self): class MixedMappedModel(JsonMappedModel): __mapping__ = { 'test': Attr('test', int), 'another': Attr('another', int, serialize=False) } mapping = MixedMappedModel() mapping.test = 1 mapping.another = 2 without_result = '{"test": 1}' result_without = JsonTransmuter.transmute_to(mapping) expect(result_without).to.equal(without_result) # Make sure we can override the serialization preferences result_with = JsonTransmuter.transmute_to( mapping, to_string=False, serialize_all=True ) expect(result_with.get('test')).to.equal(1) expect(result_with.get('another')).to.equal(2) result = JsonTransmuter.transmute_from( {'test': 100, 'another': 200}, MixedMappedModel ) expect(result.test).to.equal(100) expect(result.another).to.equal(200)
def should_not_have_weird_hours(self): user_tz = ['Eastern (US & Canada)', 'Pacific (US & Canada)'] l1_time = [9, 9] l2_time = [9, 9] l3_time = [None, 9] training_data = pd.DataFrame({ 'user_tz': user_tz, 'l1_time': l1_time, 'l2_time': l2_time }) business_forecast = [{'schedule_type': 2, 'timezone': 'Eastern (US & Canada)', 'frequency': 1 }, {'schedule_type': 3, 'timezone': 'Pacific (US & Canada)', 'frequency': 2 }] smart_heuristic_model = SmartHeuristicModel() smart_heuristic_model.fit(training_data) schedule = smart_heuristic_model.\ generate_sample_schedule(business_forecast) _sum = schedule._table_df.sum().sum() expect(_sum).to.equal(8)
def should_create_a_sample_that_meets_business_forecast_criteria( self): user_tz = ['Eastern (US & Canada)', 'Pacific (US & Canada)'] l1_time = [9, 9] l2_time = [9, 9] l3_time = [None, 9] training_data = pd.DataFrame({ 'user_tz': user_tz, 'l1_time': l1_time, 'l2_time': l2_time }) business_forecast = [{ 'schedule_type': 2, 'timezone': 'Eastern (US & Canada)', 'frequency': 1 }, { 'schedule_type': 3, 'timezone': 'Pacific (US & Canada)', 'frequency': 2 }] dumb_model = DumbModel() dumb_model.fit(training_data) schedule = dumb_model.generate_sample_schedule( business_forecast) _sum = schedule._table_df.sum().sum() expect(_sum).to.equal(8)
def transmute_from_with_different_attr_naming(self): test_json = '{"my-thing": "something"}' result = JsonTransmuter.transmute_from(test_json, TestDifferentAttrNaming) expect(result.my_thing).to.equal('something')
def can_connect_with_args(self): self.ssh_client.connect(host='sample.host', port=80, credentials=self.ssh_credentials) expect(self.ssh_client.host).to.equal('sample.host') expect(self.ssh_client.port).to.equal(80)
def raises_exception_on_unsupported_provider(self, get_target, get_driver): target = self.TARGET_WITH_UNSUPPORTED_PROVIDER driver_stub = self._get_libcloud_driver_stub([]) get_target.return_value = target get_driver.return_value = driver_stub expect(self.plugin.execute_action, [self.job, self.action]) \ .to.raise_a(Exception)
def raises_exception_on_invalid_address(self, get_target, get_driver): target = self.TARGET_WITH_IP_ADDRESS driver_stub = self._get_libcloud_driver_stub([]) get_target.return_value = target get_driver.return_value = driver_stub expect(self.plugin.execute_action, [self.job, self.action]) \ .to.raise_a(Exception)
def run_requires_a_project_cfg(self): config._config = None try: app.main(['run', 'bam']) except SystemExit: err_msg = 'Error: Could not file project configuration!' expect(err_msg).to.be_in(self.stdout.getvalue())
def can_extend(self): child = TestModel() child.thing = 'bam' model = TestListModel() model.extend([child]) expect(model[0]).to.equal(child)
def can_connect_with_args(self): self.ssh_client.connect( host='sample.host', port=80, credentials=self.ssh_credentials) expect(self.ssh_client.host).to.equal('sample.host') expect(self.ssh_client.port).to.equal(80)
def transmute_from_with_all_required_attrs(self): result = JsonTransmuter.transmute_from( '{"test": 1, "other": 2}', TestRequiredMappedModel, ) expect(result.test).to.equal(1) expect(result.other).to.equal(2)
def can_recreate(self): # Calling without an environment existing venv.argument_handler('recreate', None) expect(os.path.exists(venv.ENV_PATH)).to.be_true() # Calling again now that the environment exists venv.argument_handler('recreate', None) expect(os.path.exists(venv.ENV_PATH)).to.be_true()
def transmute_to_missing_required_attr_raises(self): model = TestRequiredMappedModel() model.test = 1 expect( JsonTransmuter.transmute_to, [model] ).to.raise_a(RequiredAttributeError)
def can_build_a_target_from_a_dictionary(self): obj = build_target_obj() expect(obj.name).to.equal('bam') expect('play.yml').to.be_in(obj.playbooks) expect(obj.inventory).to.equal('inventory.ini') expect(obj.tags).to.equal('nope') expect(obj.options).to.equal('-vvvv')
def transmute_from_with_missing_required_attr_raises(self): expect( JsonTransmuter.transmute_from, [ '{"test": 1}', TestRequiredMappedModel ] ).to.raise_a(RequiredAttributeError)
def transmute_attribute_with_type(self, attr_type, attr_data, attr_result): class FlexMapping(JsonMappedModel): __mapping__ = {'test': Attr('test', attr_type)} data = '{{"test": {0} }}'.format(attr_data) result = JsonTransmuter.transmute_from(data, FlexMapping) expect(result.test).to.equal(attr_result)
def can_authenticate(self, post_func): r = get_keystone_v2_auth_resp() post_func.return_value = r self.auth(r) expect(r.headers.get('X-Auth-Token')).to.equal('some_token') expect(r.headers.get('X-Project-Id')).to.equal('some_tenant')
def can_get(self): child = TestModel() child.thing = 'bam' model = TestListModel() model.collection = [child] expect(model[0]).to.equal(child)
def can_build_a_target_from_a_dictionary(self): obj = build_target_obj() expect(obj.name).to.equal("bam") expect("play.yml").to.be_in(obj.playbooks) expect(obj.inventory).to.equal("inventory.ini") expect(obj.tags).to.equal("nope") expect(obj.options).to.equal("-vvvv")
def can_append(self): child = TestModel() child.thing = 'bam' model = TestListModel() model.append(child) expect(model[0]).to.equal(child)
def should_have_a_default_get_method(self): plugin = GenericPlugin() resp, req = Response(), object() plugin.on_get(req=req, resp=resp) json_body = json.loads(resp.body) expect(resp.status).to.equal(HTTP_200) expect(json_body['help']).to.equal(AbstractPlugin.API_HELP)
def run_requires_a_venv(self): config.get_config('./data/test_project.yml') try: app.main(['run', 'bam']) except SystemExit: err_msg = ('Virtual environment does not exist.. ' 'Please run: ansible-flow venv create') expect(err_msg).to.be_in(self.stdout.getvalue())
def can_serialize(self): cfg = TestConfig() cfg.nope = 'testing' handler = generic.GenericHandler() raw = handler.serialize(cfg) expect(type(raw)).to.equal(dict) expect(raw['nope']).to.equal('testing')