def __init__(self, level): self.level = level self.inventory = Inventory(self) self.x_dim = 0 self.y_dim = 0 self.cells = [] self.cells_dict = { } # {0: {0: <cell>, 1: <cell>}, 1: {0: <cell>, 1: <cell>},...} self.path = MapPath(self) self.enter_cell = None self.exit_cell = None
def test_integration_main(self): blanket = Inventory(100, "blanket", 300, 100) blanket_details = blanket.return_as_dictionary() chair = Furniture(200, "chair", 200, 50, "Plastic", "S") chair_details = chair.return_as_dictionary() monitor = ElectricAppliance(300, "IPS Monitor", 500, 50, "Asus", 220) monitor_details = monitor.return_as_dictionary() self.assertEqual(100, blanket_details["product_code"]) self.assertEqual(200, chair_details["product_code"]) self.assertEqual(300, monitor_details["product_code"])
class GetHandler: def __init__(self, request): self.alerts = Alerts() self.inventory = Inventory() self.request = request def create_http_response(self): return HttpResponse(template.render(self.create_context(), self.request)) def handle_get_request(self): pass def create_context(self): return {'alerts': self.get_alerts(), 'cve_search_url': config.get_cve_search_url()} def get_alerts(self): alerts = self.alerts.get_alerts() for alert in alerts: self.add_cpe_to_alert(alert) format_alert_log(alert) return alerts def add_cpe_to_alert(self, alert): sw = self.inventory.get_software_by_id(alert.get('software_id')) if sw is not None: alert.update({'uri': sw.get('cpe').get('uri_binding')}) alert.update({'product': sw.get('product')}) alert.update({'vendor': sw.get('vendor')}) alert.update({'version': sw.get('version')}) else: alert.update({'product': 'product was removed from database'})
def test_insert_new_software_products_to_db(self): item = copy(NEW_SOFTWARE_1) item.update({'id': self.generate_expected_software_id(item)}) self.inventory_collection.insert_one(item) item = copy(NEW_SOFTWARE_2) item.update({'id': self.generate_expected_software_id(item)}) self.inventory_collection.insert_one(item) item = copy(NEW_SOFTWARE_3) item.update({'id': self.generate_expected_software_id(item)}) self.inventory_collection.insert_one(item) with patch('config.get_database_host', return_value=DB_HOST): with patch('config.get_database_port', return_value=DB_PORT): with patch('config.get_database_name', return_value=IVA_DB_NAME): with patch('config.is_database_authentication_enabled', return_value=False): with patch('inventory.glpi_inventory.read_inventory', return_value=GLPI_DB_ITEMS): self.assertEqual(3, self.inventory_collection.count()) Inventory().insert_new_software_products_to_db() self.assertEqual(5, self.inventory_collection.count())
class InventoryWithExistingProductTest(TestCase): def setUp(self): repository = load_inmemoryrepository_with_existing_products() self.inventory = Inventory(repository=repository) def test_getproduct_returns_existing_product(self): expected_product_id = 1 returned_product = self.inventory.get_product( whose='id', equals=expected_product_id) self.assertEqual(expected_product_id, returned_product.id) def test_getproduct_using_name_field_returns_existing_product(self): expected_product_id = 1 returned_product = self.inventory.get_product( whose='name', equals='Existing Product') self.assertEqual(expected_product_id, returned_product.id) def test_exception_raised_if_getproduct_match_more_than_one_product(self): with self.assertRaises(LookupError): self.inventory.get_product(whose='name', equals='Duplicated Product')
class GetHandler: def __init__(self, request): self.cpe_inventory = SoftwareCPE() self.request = request self.inventory = Inventory() def create_http_response(self): context = self.create_context() return HttpResponse(template.render(context, self.request)) def create_context(self): return { 'inventory': self.inventory.get_software_products_with_assigned_cpe() }
class PostHandler: def __init__(self, request): self.sw_cpe = SoftwareCPE() self.wfn_converter = WFNConverter() self.inventory = Inventory() self.request = request self.decoder = Decoder() def handle_request(self): if not self.request.POST.get('check'): sw_cpe_dict = self.sw_cpe.create_sw_cpe_dict(self.get_wfn()) self.sw_cpe.assign_cpe_to_software(sw_cpe_dict, self.get_software_id()) return self.create_http_response_for_add_cpe(sw_cpe_dict) return self.create_http_response_for_verify_cpe_exists() def get_wfn(self): return self.wfn_converter.create_wfn_from_user_input(self.request.POST) def get_software_id(self): return self.request.POST.get('software_id') def create_http_response_for_verify_cpe_exists(self): uri = self.wfn_converter.convert_wfn_to_uri(self.get_wfn()) software = self.sw_cpe.get_software_cpe_by_uri(uri) if software is not None: return JsonResponse({ 'result': 'exist', 'uri_binding': self.decoder.decode_non_alphanumeric_characters(uri) }) return JsonResponse({ 'result': 'not_exist', 'uri_binding': self.decoder.decode_non_alphanumeric_characters(uri) }) def create_http_response_for_add_cpe(self, cpe_doc): return HttpResponse( software_cpe_template.render( { 'inventory': self.inventory.get_software_products_with_assigned_cpe(), 'updated': cpe_doc.get('uri_binding') }, self.request))
def __init__(self): super().__init__() w = int(self.screen.get_width() / 1.7) h = convert.scale_h([5504, 3808], w) x = int(self.screen.get_width() / 2 - w / 2) y = int(self.screen.get_height() / 2 - h / 2) self.platform_rect = [x, y, w, h] self.player = Player( self.screen, [self.platform_rect[0], self.platform_rect[1], 25, 25], self.platform_rect, 150, name='player', save_entity=False) self.inventory = Inventory() self.inventory_display = InventoryDisplay(self.screen, [self.player]) self.inventory_open = False
class CVEMatches: def __init__(self): self.inventory = Inventory() self.alerts = Alerts() self.db = Database() def insert_software_cve_matches(self, software_id, matches): new_matches = [] matches = format_matches(matches) for old_match in self.get_software_cve_matches(software_id): is_match = False for match in matches: if old_match.get('cve_id') == match.get('cve_id'): new_matches.append(old_match) matches.remove(match) is_match = True break if not is_match: self.remove_old_cve_match_from_alert(old_match, software_id) new_matches.extend(matches) sw = self.inventory.get_software_by_id(software_id) self.update_matches_in_db( software_id, sort_cve_matches_by_version(new_matches, get_sw_version(sw))) def remove_old_cve_match_from_alert(self, old_match, software_id): if is_cve_match_positive(old_match): self.alerts.remove_cve_from_alert(software_id, old_match.get('cve_id')) def add_new_cve_match_to_software(self, software_id, new_match): cve_matches = self.get_software_cve_matches(software_id) self.update_matches_in_db( software_id, add_new_match_to_list(cve_matches, format_match(new_match))) def set_cve_matches_group_as_removed(self, software_id, cve_id_master): group = self.get_software_cve_matches_with_same_cpe_entries_as_cve( software_id, cve_id_master) for match in group: self.set_cve_match_as_removed(software_id, match.get('cve_id')) def set_cve_match_as_removed(self, software_id, cve_id): self.update_cve_match_status(software_id, cve_id, 'removed', 1) def restore_cve_matches_group(self, software_id, cve_id_master): group = self.get_software_cve_matches_with_same_cpe_entries_as_cve( software_id, cve_id_master) for match in group: self.restore_cve_match(software_id, match.get('cve_id')) def restore_cve_match(self, software_id, cve_id): self.update_cve_match_status(software_id, cve_id, 'removed', 0) def set_cve_matches_group_as_positive(self, software_id, cve_id_master): group = self.get_software_cve_matches_with_same_cpe_entries_as_cve( software_id, cve_id_master) for match in group: self.set_cve_match_as_positive(software_id, match.get('cve_id')) def set_cve_match_as_positive(self, software_id, cve_id): self.update_cve_match_status(software_id, cve_id, 'positive', 1) self.alerts.insert_alert(software_id, cve_id) def set_cve_matches_group_as_negative(self, software_id, cve_id_master): group = self.get_software_cve_matches_with_same_cpe_entries_as_cve( software_id, cve_id_master) for match in group: self.set_cve_match_as_negative(software_id, match.get('cve_id')) def set_cve_match_as_negative(self, software_id, cve_id): self.update_cve_match_status(software_id, cve_id, 'positive', 0) self.alerts.remove_cve_from_alert(software_id, cve_id) def update_cve_match_status(self, software_id, cve_id, field, status): matches = self.get_software_cve_matches(software_id) for match in matches: if match.get('cve_id') == cve_id: match.update({field: status}) self.update_matches_in_db(software_id, matches) break def get_software_cve_matches_with_same_cpe_entries_as_cve( self, software_id, cve_id): cve_matches = self.get_software_cve_matches(software_id) cve_match_a = get_cve_match_from_matches(cve_id, cve_matches) matches_with_same_cpes = [] for cve_match_b in cve_matches: if equal_removed_and_positive_status(cve_match_a, cve_match_b): if equal_cpe_entries(get_cpe_entries_from_cve(cve_match_a), get_cpe_entries_from_cve(cve_match_b)): matches_with_same_cpes.append(cve_match_b) return matches_with_same_cpes def get_software_cve_matches(self, software_id): software = self.get_software(software_id) return get_sw_cve_matches(software) def get_vulnerable_software_items(self): vulnerable_software = [] for software in self.get_software_items(): if is_vulnerable(software): vulnerable_software.append(software) return vulnerable_software def exist_cve_matches_for_software(self, software_id): return len(self.get_software_cve_matches(software_id)) > 0 def get_software_items(self): return self.db.get_documents_from_collection(INVENTORY_DB_COLLECTION) def remove_software_cve_matches(self, software_id): self.update_matches_in_db(software_id, []) def update_matches_in_db(self, software_id, matches): self.db.update_document_in_collection({'id': software_id}, {'cve_matches': matches}, INVENTORY_DB_COLLECTION) def get_software(self, software_id): return self.db.search_document_in_collection({'id': software_id}, INVENTORY_DB_COLLECTION) def get_cve_matches(self, filters=None): cve_matches = [] for software in self.inventory.get_inventory(): append_software_matches_to_list(software, cve_matches) return filter_matches(filters, cve_matches) def get_vendor_product_cve_matches(self, vendor='all', product='all', filters=None): if vendor != 'all': cve_matches = [] for software in self.inventory.get_inventory(): if is_vendor_and_product(vendor, product, software): append_software_matches_to_list(software, cve_matches) return filter_matches(filters, cve_matches) return self.get_cve_matches(filters)
def __init__(self, request): self.sw_cpe = SoftwareCPE() self.wfn_converter = WFNConverter() self.inventory = Inventory() self.request = request self.decoder = Decoder()
def setUp(self): self.product = Product(name='foo', price=100) self.inventory = Inventory(repository=InMemoryRepository())
def number_new_glpi_items(): return len(Inventory().get_software_products_without_assigned_cpe())
def get_software_products(): return Inventory().get_software_products_with_assigned_cpe()
def __init__(self): self.inventory = Inventory() self.alerts = Alerts() self.db = Database()
class CVEMatcher: def __init__(self): self.db = Database() self.wfn_converter = WFNConverter() self.inventory = Inventory() def search_cves_for_cpe(self, uri_binding): wfn = self.wfn_converter.convert_cpe_uri_to_wfn(uri_binding) matches_a = self.search_cves(wfn) matches_b = self.search_cves_with_summary(wfn) merge_lists(matches_a, matches_b) return matches_a def search_cves(self, wfn): cve_matches = [] for vendor in self.get_vendor_candidates(wfn): for product in self.get_product_candidates(wfn): tmp_cve_matches = self.search_cves_by_product_and_vendor( product, vendor) filtered_matches = filter_cpe_entries_in_cve_matches_by_version( tmp_cve_matches, wfn) cve_matches.extend(filtered_matches) return cve_matches def get_vendor_candidates(self, wfn): candidates = [] wfn_vendor = get_vendor_from_wfn(wfn) for v in self.inventory.get_vendors(): if are_strings_similar(v, wfn_vendor): candidates.append(v) return candidates def get_product_candidates(self, wfn): candidates = [] wfn_product = get_product_from_wfn(wfn) for p in self.inventory.get_products(): if are_strings_similar(p, wfn_product): candidates.append(p) wfn_vendor = get_vendor_from_wfn(wfn) if wfn_vendor in wfn_product: candidates.append( remove_vendor_from_product(wfn_product, wfn_vendor)) else: candidates.append( add_vendor_to_product(wfn_vendor, wfn_product, 'left')) candidates.append( add_vendor_to_product(wfn_vendor, wfn_product, 'right')) return candidates def search_cves_by_product_and_vendor(self, product, vendor): search_condition = create_search_condition(product, vendor) aggregation = create_aggregation(product, vendor) return self.db.search_documents_and_aggregate(search_condition, aggregation, IVA_CVE_COLLECTION) def search_cves_with_summary(self, wfn): matches = [] for cve in self.get_cve_without_cpe_entries(): if is_product_and_vendor_in_cve_summary(cve, wfn): matches.append(cve) return matches def get_cve_without_cpe_entries(self): return self.db.search_documents_in_collection( {'cpe_entries': { '$size': 0 }}, IVA_CVE_COLLECTION)
class Map(object): """The map that a player will navigate.""" def __init__(self, level): self.level = level self.inventory = Inventory(self) self.x_dim = 0 self.y_dim = 0 self.cells = [] self.cells_dict = { } # {0: {0: <cell>, 1: <cell>}, 1: {0: <cell>, 1: <cell>},...} self.path = MapPath(self) self.enter_cell = None self.exit_cell = None def __build_cells(self, x_dim, y_dim): """Build collection of cells based on x and y dimensions.""" for x in range(x_dim): if x not in self.cells_dict: self.cells_dict[x] = {} for y in range(y_dim): if y not in self.cells_dict[x]: cell = MapCell(self, x, y) self.cells_dict[x][y] = cell self.cells.append(cell) def build(self): """Build the map from the config for the provided level number.""" tool_factory = ToolFactory() part_factory = PartFactory() artifact_factory = ArtifactFactory() map_config = level_config[self.level.number]['map'] self.x_dim = map_config['x_dimension'] self.y_dim = map_config['y_dimension'] enter_coord = map_config['coord_enter'] exit_coord = map_config['coord_exit'] self.__build_cells(self.x_dim, self.y_dim) self.enter_cell = self.get_cell(*enter_coord) self.exit_cell = self.get_cell(*exit_coord) for path_cell_config in map_config['path_cells']: path_cell = self.get_cell(*path_cell_config['coordinates']) path_cell.story = path_cell_config['story'] self.path.add_cell(path_cell) for system_interface in self.level.system.interfaces: interface_cell = self.get_cell(*system_interface.location) interface_cell.add_interface(system_interface) for system_device in self.level.system.devices: device_cell = self.get_cell(*system_device.location) device_cell.add_device(system_device) for tool_config in map_config['tools']: new_tool = tool_factory.make_from_config(self, tool_config) self.inventory.add_item(new_tool) for part_config in map_config['parts']: new_part = part_factory.make_from_config(self, part_config) self.inventory.add_item(new_part) for artifact_config in map_config['artifacts']: new_artifact = artifact_factory.make_from_config( self, artifact_config) self.inventory.add_item(new_artifact) for map_tool in self.inventory.get_tools(): tool_cell = self.get_cell(*map_tool.location) tool_cell.add_tool(map_tool) for map_part in self.inventory.get_parts(): part_cell = self.get_cell(*map_part.location) part_cell.add_part(map_part) for map_artifact in self.inventory.get_artifacts(): artifact_cell = self.get_cell(*map_artifact.location) artifact_cell.add_artifact(map_artifact) @property def interfaces(self): """Interfaces from all map cells""" return [i for c in self.cells for i in c.interfaces] @property def devices(self): """Devices from all map cells""" return [d for c in self.cells for d in c.devices] @property def components(self): """Components from all map cells.""" return [o for c in self.cells for o in c.components] @property def tools(self): """Tools from all map cells""" return [t for c in self.cells for t in c.tools] @property def parts(self): """Parts from all map cells""" return [p for c in self.cells for p in c.parts] @property def artifacts(self): """Artifacts from all map cells""" return [a for c in self.cells for a in c.artifacts] @property def items(self): """Items from all map cells.""" return [i for c in self.cells for i in c.items] def get_cell(self, x, y): """Return the cell at the provided coordinates if it exists, otherwise None.""" try: return self.cells_dict[x][y] except KeyError: return None def get_d4_cells(self, x, y): """Return the cells above, right, below, and left of the provided coordinates.""" d4_cells = [] d4_coords = [(x, y - 1), (x + 1, y), (x, y + 1), (x - 1, y)] for coord in d4_coords: d4_cells.append(self.get_cell(*coord)) return d4_cells def get_d4_interfaces(self, x, y): """Return the interfaces for the d4 cells around the provided coordinates.""" d4_interfaces = [] for cell in self.get_d4_cells(x, y): if isinstance(cell, MapCell): d4_interfaces.append(cell.interfaces) else: d4_interfaces.append([]) return d4_interfaces def get_d4_devices(self, x, y): """Return the devices for the d4 cells around the provided coordinates.""" d4_devices = [] for cell in self.get_d4_cells(x, y): if isinstance(cell, MapCell): d4_devices.append(cell.devices) else: d4_devices.append([]) return d4_devices def get_d4_components(self, x, y): """Return the components for the d4 cells around the provided coordinates.""" d4_interfaces = self.get_d4_interfaces(x, y) d4_devices = self.get_d4_devices(x, y) d4_components = [ items[0] + items[1] for items in zip(d4_interfaces, d4_devices) ] return d4_components def get_d4_tools(self, x, y): """Return the tools for the d4 cells around the provided coordinates.""" d4_tools = [] for cell in self.get_d4_cells(x, y): if isinstance(cell, MapCell): d4_tools.append(cell.tools) else: d4_tools.append([]) return d4_tools def get_d4_parts(self, x, y): """Return the tools for the d4 cells around the provided coordinates.""" d4_parts = [] for cell in self.get_d4_cells(x, y): if isinstance(cell, MapCell): d4_parts.append(cell.parts) else: d4_parts.append([]) return d4_parts def get_d4_artifacts(self, x, y): """Return the artifacts for the d4 cells around the provided coordinates.""" d4_artifacts = [] for cell in self.get_d4_cells(x, y): if isinstance(cell, MapCell): d4_artifacts.append(cell.artifacts) else: d4_artifacts.append([]) return d4_artifacts def get_d4_items(self, x, y): """Return the items for the d4 cells around the provided coordinates.""" d4_tools = self.get_d4_tools(x, y) d4_parts = self.get_d4_parts(x, y) d4_artifacts = self.get_d4_artifacts(x, y) d4_items = [ items[0] + items[1] for items in zip(d4_tools, d4_parts, d4_artifacts) ] return d4_items
def __init__(self, request): self.alerts = Alerts() self.inventory = Inventory() self.request = request
def __init__(self): self.db = Database() self.wfn_converter = WFNConverter() self.inventory = Inventory()
def __init__(self, screen, entities): self.screen = screen self.entities = entities # list with objects self.current_entity = -1 # what current entity are we working with self.length = 4 self.margin = int(self.screen.get_width() / 288) self.inventory = Inventory() # Inventory elements # Inventory background # 1. Global inventory self.inventory_rect = [ self.screen.get_width() / 2 - int(self.screen.get_width() / 3.5 / 2), int(self.screen.get_height() / 3), int(self.screen.get_width() / 3.5), scale_h([1, 1], int(self.screen.get_width() / 3.5)) ] self.page = 0 # Text and Buttons self.button_page_up = Button('>', [ self.inventory_rect[0] + self.inventory_rect[2], self.inventory_rect[1], int(self.inventory_rect[2] / 6), self.inventory_rect[3] ], self.screen, colors=[(105, 105, 105), (169, 169, 169)]) self.button_page_down = Button('<', [ self.inventory_rect[0] - int(self.inventory_rect[2] / 6), self.inventory_rect[1], int(self.inventory_rect[2] / 6), self.inventory_rect[3] ], self.screen, colors=[(105, 105, 105), (169, 169, 169)]) self.page_text = Text( self.screen, str(self.page + 1), [ self.inventory_rect[0], self.inventory_rect[1] - 50, self.inventory_rect[2], 50 ], font_size=42) self.button_delay_1 = time.time() + 0.15 self.button_delay_2 = time.time() + 0.15 self.click_delay = time.time() + 0.15 # 2. Preview self.preview_image = None self.preview_rect = [] self.box_width = None # slots # weapon self.weapon_rect = [] self.weapon_placeholder = None self.weapon_equipped = None # helmet self.helmet_rect = [] self.helmet_placeholder = None self.helmet_equipped = None # chestplate self.chestplate_rect = [] self.chestplate_placeholder = None self.chestplate_equipped = None # boots self.boots_rect = [] self.boots_placeholder = None self.boots_equipped = None # Center box self.center_box = [] # Grid self.grid = [] self.mouse_down = False # Set value to everything self.scale()
def add_tabs(self): """ adds new tabs """ global logger if ('Inventory', True) in self.access: logger.info('initiating Inventory') icon = QIcon() icon.addPixmap(QPixmap(":/images/inventory.png"), QIcon.Normal, QIcon.Off) from inventory.inventory import Inventory inventory = Inventory() # inventory.inventory_tab_1.setToolTip("Inventory Section") self.main_tabWidget.addTab(inventory.inventory_tab_1, icon, "") inventory.inventory_detail_tabWidget.setCurrentIndex(0) else: self.inventory_frame_1.setVisible(False) self.progress.setLabelText('Inventory Done....') self.progress.setValue(2) if ('Billing', True) in self.access: logger.info('initiating Billing') icon1 = QIcon() icon1.addPixmap(QPixmap(":/images/billing.png"), QIcon.Normal, QIcon.Off) from billing.billing import Billing bill = Billing() # bill.billing_tab_2.setToolTip("Billing Section") self.main_tabWidget.addTab(bill.billing_tab_2, icon1, "") bill.billing_detail_tabWidget.setCurrentIndex(0) else: self.billing_frame_2.setVisible(False) self.progress.setLabelText('Billing Done...') self.progress.setValue(3) if ('Employee', True) in self.access: logger.info('initiating Employee') icon2 = QIcon() icon2.addPixmap(QPixmap(":/images/employee.png"), QIcon.Normal, QIcon.Off) from employee.employee import Employee employee = Employee() # employee.employee_tab_3.setToolTip("Employee Section") self.main_tabWidget.addTab(employee.employee_tab_3, icon2, "") employee.employee_detail_tabWidget.setCurrentIndex(0) else: self.employee_frame_3.setVisible(False) self.progress.setLabelText('Employee Done...') self.progress.setValue(4) if ('Menu', True) in self.access: logger.info('initiating Menu') icon3 = QIcon() icon3.addPixmap(QPixmap(":/images/menu.png"), QIcon.Normal, QIcon.Off) from menu.menu import Menu menu = Menu() # menu.menu_tab_4.setToolTip("Menu Section") self.main_tabWidget.addTab(menu.menu_tab_4, icon3, "") menu.menu_detail_tabWidget.setCurrentIndex(0) else: self.menu_frame_4.setVisible(False) self.progress.setLabelText('Menu Done....') self.progress.setValue(5) if ('Report', True) in self.access: logger.info('initiating Report') icon4 = QIcon() icon4.addPixmap(QPixmap(":/images/report.png"), QIcon.Normal, QIcon.Off) from report.report import Report report = Report() # report.report_tab_5.setToolTip("Report Section") self.main_tabWidget.addTab(report.report_tab_5, icon4, "") report.report_detail_tabWidget.setCurrentIndex(0) else: self.report_frame_5.setVisible(False) self.progress.setLabelText('Report Done....') self.progress.setValue(6) if ('Waste', True) in self.access: logger.info('initiating Waste') icon5 = QIcon() icon5.addPixmap(QPixmap(":/images/waste.png"), QIcon.Normal, QIcon.Off) from waste.waste import Waste waste = Waste() # waste.waste_tab_6.setToolTip("Waste Section") self.main_tabWidget.addTab(waste.waste_tab_6, icon5, "") waste.waste_detail_tabWidget.setCurrentIndex(0) else: self.waste_frame_6.setVisible(False) self.progress.setLabelText('Waste Done....') self.progress.setValue(7)
def __init__(self, request): self.cpe_inventory = SoftwareCPE() self.request = request self.inventory = Inventory()
def setUp(self): repository = load_inmemoryrepository_with_existing_products() self.inventory = Inventory(repository=repository)
def test_inventory(self): inv = Inventory("1", "one", "2.99", "rentalprice") self.assertEqual("1", inv.return_as_dictionary()["product_code"])
class InventoryTest(TestCase): def setUp(self): self.product = Product(name='foo', price=100) self.inventory = Inventory(repository=InMemoryRepository()) def test_adds_product(self): self.inventory.add(self.product) self.assertTrue(self.product in self.inventory) def test_exception_raised_when_product_not_found(self): some_product_id_that_hasnt_been_added = 9999 with self.assertRaises(LookupError): self.inventory.get_product( whose='id', equals=some_product_id_that_hasnt_been_added) def test_exception_raised_when_attempt_to_add_product_with_id(self): self.product.id = 1 with self.assertRaises(ValueError): self.inventory.add(self.product) def test_containment_checks_for_product_id(self): product_with_identical_data_but_different_id = Product(name='foo', price=100) self.inventory.add(self.product) self.assertFalse( product_with_identical_data_but_different_id in self.inventory) def test_getproduct_returns_same_product_but_different_object(self): product = Product(name='New Product', price=1) self.inventory.add(product) returned_product = self.inventory.get_product(whose='id', equals=product.id) self.assertNotEqual(id(returned_product), id(product)) def test_multiple_insertions_at_once(self): products = [ Product(name='test multiple insertions 1', price=1), Product(name='test multiple insertions 2', price=2), Product(name='test multiple insertions 3', price=3), ] self.inventory.add_many(products) self.assertTrue(all(product in self.inventory for product in products)) def test_raise_exception_if_any_product_passed_to_addmany_has_id(self): products = [ Product(name='test multiple insertions 1', price=1), Product(name='test multiple insertions 2', price=2, id_=1), Product(name='test multiple insertions 3', price=3), ] with self.assertRaises(ValueError): self.inventory.add_many(products)
def get_software(self): return Inventory().get_software_by_id(self.software_id)
def get_software(self): return Inventory().get_software_by_id(self.request.GET.get('id'))