From bfa0734cc684c2a73fcb225bd6d138010f6b15bf Mon Sep 17 00:00:00 2001 From: luisramos0 Date: Thu, 14 Feb 2019 15:35:47 +0000 Subject: [PATCH] Break order_cycle_spec.js in specific files like create controller, edit controller and services Move bulk_product_update_spec.js to its apropriate place under /admin --- .../bulk_product_update_spec.js.coffee | 0 .../controllers/create_spec.js.coffee | 161 +++ .../controllers/edit_spec.js.coffee | 166 +++ .../services/enterprise_fee_spec.js.coffee | 37 + .../services/enterprise_spec.js.coffee | 75 ++ .../services/order_cycle_spec.js.coffee | 520 ++++++++++ .../unit/order_cycle_spec.js.coffee | 968 ------------------ 7 files changed, 959 insertions(+), 968 deletions(-) rename spec/javascripts/unit/{ => admin}/bulk_product_update_spec.js.coffee (100%) create mode 100644 spec/javascripts/unit/admin/order_cycles/controllers/create_spec.js.coffee create mode 100644 spec/javascripts/unit/admin/order_cycles/controllers/edit_spec.js.coffee create mode 100644 spec/javascripts/unit/admin/order_cycles/services/enterprise_fee_spec.js.coffee create mode 100644 spec/javascripts/unit/admin/order_cycles/services/enterprise_spec.js.coffee create mode 100644 spec/javascripts/unit/admin/order_cycles/services/order_cycle_spec.js.coffee delete mode 100644 spec/javascripts/unit/order_cycle_spec.js.coffee diff --git a/spec/javascripts/unit/bulk_product_update_spec.js.coffee b/spec/javascripts/unit/admin/bulk_product_update_spec.js.coffee similarity index 100% rename from spec/javascripts/unit/bulk_product_update_spec.js.coffee rename to spec/javascripts/unit/admin/bulk_product_update_spec.js.coffee diff --git a/spec/javascripts/unit/admin/order_cycles/controllers/create_spec.js.coffee b/spec/javascripts/unit/admin/order_cycles/controllers/create_spec.js.coffee new file mode 100644 index 0000000000..d07c80f542 --- /dev/null +++ b/spec/javascripts/unit/admin/order_cycles/controllers/create_spec.js.coffee @@ -0,0 +1,161 @@ +describe 'AdminCreateOrderCycleCtrl', -> + ctrl = null + scope = null + event = null + OrderCycle = null + Enterprise = null + EnterpriseFee = null + + beforeEach -> + scope = + order_cycle_form: jasmine.createSpyObj('order_cycle_form', ['$dirty']) + $watch: jasmine.createSpy('$watch') + event = + preventDefault: jasmine.createSpy('preventDefault') + OrderCycle = + exchangeSelectedVariants: jasmine.createSpy('exchangeSelectedVariants').and.returnValue('variants selected') + productSuppliedToOrderCycle: jasmine.createSpy('productSuppliedToOrderCycle').and.returnValue('product supplied') + variantSuppliedToOrderCycle: jasmine.createSpy('variantSuppliedToOrderCycle').and.returnValue('variant supplied') + exchangeDirection: jasmine.createSpy('exchangeDirection').and.returnValue('exchange direction') + toggleProducts: jasmine.createSpy('toggleProducts') + setExchangeVariants: jasmine.createSpy('setExchangeVariants') + addSupplier: jasmine.createSpy('addSupplier') + addDistributor: jasmine.createSpy('addDistributor') + removeExchange: jasmine.createSpy('removeExchange') + addCoordinatorFee: jasmine.createSpy('addCoordinatorFee') + removeCoordinatorFee: jasmine.createSpy('removeCoordinatorFee') + addExchangeFee: jasmine.createSpy('addExchangeFee') + removeExchangeFee: jasmine.createSpy('removeExchangeFee') + removeDistributionOfVariant: jasmine.createSpy('removeDistributionOfVariant') + create: jasmine.createSpy('create') + new: jasmine.createSpy('new').and.returnValue "my order cycle" + Enterprise = + index: jasmine.createSpy('index').and.returnValue('enterprises list') + supplied_products: 'supplied products' + suppliedVariants: jasmine.createSpy('suppliedVariants').and.returnValue('supplied variants') + totalVariants: jasmine.createSpy('totalVariants').and.returnValue('variants total') + EnterpriseFee = + index: jasmine.createSpy('index').and.returnValue('enterprise fees list') + forEnterprise: jasmine.createSpy('forEnterprise').and.returnValue('enterprise fees for enterprise') + ocInstance = {} + + module('admin.orderCycles') + inject ($controller) -> + ctrl = $controller 'AdminCreateOrderCycleCtrl', {$scope: scope, OrderCycle: OrderCycle, Enterprise: Enterprise, EnterpriseFee: EnterpriseFee, ocInstance: ocInstance} + + + it 'Loads enterprises and supplied products', -> + expect(Enterprise.index).toHaveBeenCalled() + expect(scope.enterprises).toEqual('enterprises list') + expect(scope.supplied_products).toEqual('supplied products') + + it 'Loads enterprise fees', -> + expect(EnterpriseFee.index).toHaveBeenCalled() + expect(scope.enterprise_fees).toEqual('enterprise fees list') + + it 'Loads order cycles', -> + expect(scope.order_cycle).toEqual('my order cycle') + + describe 'Reporting when all resources are loaded', -> + beforeEach inject (RequestMonitor) -> + RequestMonitor.loading = false + Enterprise.loaded = true + EnterpriseFee.loaded = true + OrderCycle.loaded = true + + it 'returns true when all resources are loaded', -> + expect(scope.loaded()).toBe(true) + + it 'returns false otherwise', -> + EnterpriseFee.loaded = false + expect(scope.loaded()).toBe(false) + + it "delegates suppliedVariants to Enterprise", -> + expect(scope.suppliedVariants('enterprise_id')).toEqual('supplied variants') + expect(Enterprise.suppliedVariants).toHaveBeenCalledWith('enterprise_id') + + it 'Delegates exchangeSelectedVariants to OrderCycle', -> + expect(scope.exchangeSelectedVariants('exchange')).toEqual('variants selected') + expect(OrderCycle.exchangeSelectedVariants).toHaveBeenCalledWith('exchange') + + it "delegates setExchangeVariants to OrderCycle", -> + scope.setExchangeVariants('exchange', 'variants', 'selected') + expect(OrderCycle.setExchangeVariants).toHaveBeenCalledWith('exchange', 'variants', 'selected') + + it 'Delegates enterpriseTotalVariants to Enterprise', -> + expect(scope.enterpriseTotalVariants('enterprise')).toEqual('variants total') + expect(Enterprise.totalVariants).toHaveBeenCalledWith('enterprise') + + it 'Delegates productSuppliedToOrderCycle to OrderCycle', -> + expect(scope.productSuppliedToOrderCycle('product')).toEqual('product supplied') + expect(OrderCycle.productSuppliedToOrderCycle).toHaveBeenCalledWith('product') + + it 'Delegates variantSuppliedToOrderCycle to OrderCycle', -> + expect(scope.variantSuppliedToOrderCycle('variant')).toEqual('variant supplied') + expect(OrderCycle.variantSuppliedToOrderCycle).toHaveBeenCalledWith('variant') + + it 'Delegates exchangeDirection to OrderCycle', -> + expect(scope.exchangeDirection('exchange')).toEqual('exchange direction') + expect(OrderCycle.exchangeDirection).toHaveBeenCalledWith('exchange') + + it 'Finds enterprises participating in the order cycle that have fees', -> + scope.enterprises = + 1: {id: 1, name: 'Eaterprises'} + 2: {id: 2, name: 'Pepper Tree Place'} + 3: {id: 3, name: 'South East'} + OrderCycle.participatingEnterpriseIds = jasmine.createSpy('participatingEnterpriseIds').and.returnValue([2]) + EnterpriseFee.enterprise_fees = [ {enterprise_id: 2} ] # Pepper Tree Place has a fee + expect(scope.enterprisesWithFees()).toEqual([ + {id: 2, name: 'Pepper Tree Place'} + ]) + + it 'Delegates enterpriseFeesForEnterprise to EnterpriseFee', -> + scope.enterpriseFeesForEnterprise('123') + expect(EnterpriseFee.forEnterprise).toHaveBeenCalledWith(123) + + it 'Adds order cycle suppliers', -> + scope.new_supplier_id = 'new supplier id' + scope.addSupplier(event) + expect(event.preventDefault).toHaveBeenCalled() + expect(OrderCycle.addSupplier).toHaveBeenCalledWith('new supplier id') + + it 'Adds order cycle distributors', -> + scope.new_distributor_id = 'new distributor id' + scope.addDistributor(event) + expect(event.preventDefault).toHaveBeenCalled() + expect(OrderCycle.addDistributor).toHaveBeenCalledWith('new distributor id') + + it 'Removes order cycle exchanges', -> + scope.removeExchange(event, 'exchange') + expect(event.preventDefault).toHaveBeenCalled() + expect(OrderCycle.removeExchange).toHaveBeenCalledWith('exchange') + + it 'Adds coordinator fees', -> + scope.addCoordinatorFee(event) + expect(event.preventDefault).toHaveBeenCalled() + expect(OrderCycle.addCoordinatorFee).toHaveBeenCalled() + + it 'Removes coordinator fees', -> + scope.removeCoordinatorFee(event, 0) + expect(event.preventDefault).toHaveBeenCalled() + expect(OrderCycle.removeCoordinatorFee).toHaveBeenCalledWith(0) + + it 'Adds exchange fees', -> + scope.addExchangeFee(event) + expect(event.preventDefault).toHaveBeenCalled() + expect(OrderCycle.addExchangeFee).toHaveBeenCalled() + + it 'Removes exchange fees', -> + scope.removeExchangeFee(event, 'exchange', 0) + expect(event.preventDefault).toHaveBeenCalled() + expect(OrderCycle.removeExchangeFee).toHaveBeenCalledWith('exchange', 0) + + it 'Removes distribution of a variant', -> + scope.removeDistributionOfVariant('variant') + expect(OrderCycle.removeDistributionOfVariant).toHaveBeenCalledWith('variant') + + it 'Submits the order cycle via OrderCycle create', -> + eventMock = {preventDefault: jasmine.createSpy()} + scope.submit(eventMock,'/admin/order_cycles') + expect(eventMock.preventDefault).toHaveBeenCalled() + expect(OrderCycle.create).toHaveBeenCalledWith('/admin/order_cycles') diff --git a/spec/javascripts/unit/admin/order_cycles/controllers/edit_spec.js.coffee b/spec/javascripts/unit/admin/order_cycles/controllers/edit_spec.js.coffee new file mode 100644 index 0000000000..2f2016f5c7 --- /dev/null +++ b/spec/javascripts/unit/admin/order_cycles/controllers/edit_spec.js.coffee @@ -0,0 +1,166 @@ +describe 'AdminEditOrderCycleCtrl', -> + ctrl = null + scope = null + event = null + location = null + OrderCycle = null + Enterprise = null + EnterpriseFee = null + + beforeEach -> + scope = + order_cycle_form: jasmine.createSpyObj('order_cycle_form', ['$dirty', '$setPristine']) + $watch: jasmine.createSpy('$watch') + event = + preventDefault: jasmine.createSpy('preventDefault') + location = + absUrl: -> + 'example.com/admin/order_cycles/27/edit' + OrderCycle = + load: jasmine.createSpy('load') + exchangeSelectedVariants: jasmine.createSpy('exchangeSelectedVariants').and.returnValue('variants selected') + productSuppliedToOrderCycle: jasmine.createSpy('productSuppliedToOrderCycle').and.returnValue('product supplied') + variantSuppliedToOrderCycle: jasmine.createSpy('variantSuppliedToOrderCycle').and.returnValue('variant supplied') + exchangeDirection: jasmine.createSpy('exchangeDirection').and.returnValue('exchange direction') + toggleProducts: jasmine.createSpy('toggleProducts') + setExchangeVariants: jasmine.createSpy('setExchangeVariants') + addSupplier: jasmine.createSpy('addSupplier') + addDistributor: jasmine.createSpy('addDistributor') + removeExchange: jasmine.createSpy('removeExchange') + addCoordinatorFee: jasmine.createSpy('addCoordinatorFee') + removeCoordinatorFee: jasmine.createSpy('removeCoordinatorFee') + addExchangeFee: jasmine.createSpy('addExchangeFee') + removeExchangeFee: jasmine.createSpy('removeExchangeFee') + removeDistributionOfVariant: jasmine.createSpy('removeDistributionOfVariant') + update: jasmine.createSpy('update') + Enterprise = + index: jasmine.createSpy('index').and.returnValue('enterprises list') + supplied_products: 'supplied products' + suppliedVariants: jasmine.createSpy('suppliedVariants').and.returnValue('supplied variants') + totalVariants: jasmine.createSpy('totalVariants').and.returnValue('variants total') + EnterpriseFee = + index: jasmine.createSpy('index').and.returnValue('enterprise fees list') + forEnterprise: jasmine.createSpy('forEnterprise').and.returnValue('enterprise fees for enterprise') + + module('admin.orderCycles') + inject ($controller) -> + ctrl = $controller 'AdminEditOrderCycleCtrl', {$scope: scope, $location: location, OrderCycle: OrderCycle, Enterprise: Enterprise, EnterpriseFee: EnterpriseFee} + + it 'Loads enterprises and supplied products', -> + expect(Enterprise.index).toHaveBeenCalled() + expect(scope.enterprises).toEqual('enterprises list') + expect(scope.supplied_products).toEqual('supplied products') + + it 'Loads enterprise fees', -> + expect(EnterpriseFee.index).toHaveBeenCalled() + expect(scope.enterprise_fees).toEqual('enterprise fees list') + + it 'Loads order cycles', -> + expect(OrderCycle.load).toHaveBeenCalledWith('27') + + describe 'Reporting when all resources are loaded', -> + beforeEach inject (RequestMonitor) -> + RequestMonitor.loading = false + Enterprise.loaded = true + EnterpriseFee.loaded = true + OrderCycle.loaded = true + + it 'returns true when all resources are loaded', -> + expect(scope.loaded()).toBe(true) + + it 'returns false otherwise', -> + EnterpriseFee.loaded = false + expect(scope.loaded()).toBe(false) + + it "delegates suppliedVariants to Enterprise", -> + expect(scope.suppliedVariants('enterprise_id')).toEqual('supplied variants') + expect(Enterprise.suppliedVariants).toHaveBeenCalledWith('enterprise_id') + + it 'Delegates exchangeSelectedVariants to OrderCycle', -> + expect(scope.exchangeSelectedVariants('exchange')).toEqual('variants selected') + expect(OrderCycle.exchangeSelectedVariants).toHaveBeenCalledWith('exchange') + + it "delegates setExchangeVariants to OrderCycle", -> + scope.setExchangeVariants('exchange', 'variants', 'selected') + expect(OrderCycle.setExchangeVariants).toHaveBeenCalledWith('exchange', 'variants', 'selected') + + it 'Delegates totalVariants to Enterprise', -> + expect(scope.enterpriseTotalVariants('enterprise')).toEqual('variants total') + expect(Enterprise.totalVariants).toHaveBeenCalledWith('enterprise') + + it 'Delegates productSuppliedToOrderCycle to OrderCycle', -> + expect(scope.productSuppliedToOrderCycle('product')).toEqual('product supplied') + expect(OrderCycle.productSuppliedToOrderCycle).toHaveBeenCalledWith('product') + + it 'Delegates variantSuppliedToOrderCycle to OrderCycle', -> + expect(scope.variantSuppliedToOrderCycle('variant')).toEqual('variant supplied') + expect(OrderCycle.variantSuppliedToOrderCycle).toHaveBeenCalledWith('variant') + + it 'Delegates exchangeDirection to OrderCycle', -> + expect(scope.exchangeDirection('exchange')).toEqual('exchange direction') + expect(OrderCycle.exchangeDirection).toHaveBeenCalledWith('exchange') + + it 'Finds enterprises participating in the order cycle that have fees', -> + scope.enterprises = + 1: {id: 1, name: 'Eaterprises'} + 2: {id: 2, name: 'Pepper Tree Place'} + 3: {id: 3, name: 'South East'} + OrderCycle.participatingEnterpriseIds = jasmine.createSpy('participatingEnterpriseIds').and.returnValue([2]) + EnterpriseFee.enterprise_fees = [ {enterprise_id: 2} ] # Pepper Tree Place has a fee + expect(scope.enterprisesWithFees()).toEqual([ + {id: 2, name: 'Pepper Tree Place'} + ]) + + it 'Delegates enterpriseFeesForEnterprise to EnterpriseFee', -> + scope.enterpriseFeesForEnterprise('123') + expect(EnterpriseFee.forEnterprise).toHaveBeenCalledWith(123) + + it 'Adds order cycle suppliers', -> + scope.new_supplier_id = 'new supplier id' + scope.addSupplier(event) + expect(event.preventDefault).toHaveBeenCalled() + expect(OrderCycle.addSupplier).toHaveBeenCalledWith('new supplier id') + + it 'Adds order cycle distributors', -> + scope.new_distributor_id = 'new distributor id' + scope.addDistributor(event) + expect(event.preventDefault).toHaveBeenCalled() + expect(OrderCycle.addDistributor).toHaveBeenCalledWith('new distributor id') + + it 'Removes order cycle exchanges', -> + scope.removeExchange(event, 'exchange') + expect(event.preventDefault).toHaveBeenCalled() + expect(OrderCycle.removeExchange).toHaveBeenCalledWith('exchange') + expect(scope.order_cycle_form.$dirty).toEqual true + + it 'Adds coordinator fees', -> + scope.addCoordinatorFee(event) + expect(event.preventDefault).toHaveBeenCalled() + expect(OrderCycle.addCoordinatorFee).toHaveBeenCalled() + + it 'Removes coordinator fees', -> + scope.removeCoordinatorFee(event, 0) + expect(event.preventDefault).toHaveBeenCalled() + expect(OrderCycle.removeCoordinatorFee).toHaveBeenCalledWith(0) + expect(scope.order_cycle_form.$dirty).toEqual true + + it 'Adds exchange fees', -> + scope.addExchangeFee(event) + expect(event.preventDefault).toHaveBeenCalled() + expect(OrderCycle.addExchangeFee).toHaveBeenCalled() + + it 'Removes exchange fees', -> + scope.removeExchangeFee(event, 'exchange', 0) + expect(event.preventDefault).toHaveBeenCalled() + expect(OrderCycle.removeExchangeFee).toHaveBeenCalledWith('exchange', 0) + expect(scope.order_cycle_form.$dirty).toEqual true + + it 'Removes distribution of a variant', -> + scope.removeDistributionOfVariant('variant') + expect(OrderCycle.removeDistributionOfVariant).toHaveBeenCalledWith('variant') + + it 'Submits the order cycle via OrderCycle update', -> + eventMock = {preventDefault: jasmine.createSpy()} + scope.submit(eventMock,'/admin/order_cycles') + expect(eventMock.preventDefault).toHaveBeenCalled() + expect(OrderCycle.update).toHaveBeenCalledWith('/admin/order_cycles', scope.order_cycle_form) diff --git a/spec/javascripts/unit/admin/order_cycles/services/enterprise_fee_spec.js.coffee b/spec/javascripts/unit/admin/order_cycles/services/enterprise_fee_spec.js.coffee new file mode 100644 index 0000000000..8e31008aab --- /dev/null +++ b/spec/javascripts/unit/admin/order_cycles/services/enterprise_fee_spec.js.coffee @@ -0,0 +1,37 @@ +describe 'EnterpriseFee service', -> + $httpBackend = null + EnterpriseFee = null + + beforeEach -> + module 'admin.orderCycles' + inject ($injector, _$httpBackend_)-> + EnterpriseFee = $injector.get('EnterpriseFee') + $httpBackend = _$httpBackend_ + $httpBackend.whenGET('/admin/enterprise_fees/for_order_cycle.json').respond [ + {id: 1, name: "Yayfee", enterprise_id: 1} + {id: 2, name: "FeeTwo", enterprise_id: 2} + ] + + it 'loads enterprise fees', -> + enterprise_fees = EnterpriseFee.index() + $httpBackend.flush() + expected_fees = [ + new EnterpriseFee.EnterpriseFee({id: 1, name: "Yayfee", enterprise_id: 1}) + new EnterpriseFee.EnterpriseFee({id: 2, name: "FeeTwo", enterprise_id: 2}) + ] + for fee, i in enterprise_fees + expect(fee.id).toEqual(expected_fees[i].id) + + it 'reports its loadedness', -> + expect(EnterpriseFee.loaded).toBe(false) + EnterpriseFee.index() + $httpBackend.flush() + expect(EnterpriseFee.loaded).toBe(true) + + it 'returns enterprise fees for an enterprise', -> + all_enterprise_fees = EnterpriseFee.index() + $httpBackend.flush() + enterprise_fees = EnterpriseFee.forEnterprise(1) + expect(enterprise_fees).toEqual [ + new EnterpriseFee.EnterpriseFee({id: 1, name: "Yayfee", enterprise_id: 1}) + ] diff --git a/spec/javascripts/unit/admin/order_cycles/services/enterprise_spec.js.coffee b/spec/javascripts/unit/admin/order_cycles/services/enterprise_spec.js.coffee new file mode 100644 index 0000000000..b3a7d122de --- /dev/null +++ b/spec/javascripts/unit/admin/order_cycles/services/enterprise_spec.js.coffee @@ -0,0 +1,75 @@ +describe 'Enterprise service', -> + $httpBackend = null + Enterprise = null + + beforeEach -> + module 'admin.orderCycles' + inject ($injector, _$httpBackend_)-> + Enterprise = $injector.get('Enterprise') + $httpBackend = _$httpBackend_ + $httpBackend.whenGET('/admin/enterprises/for_order_cycle.json').respond [ + {id: 1, name: 'One', supplied_products: [1, 2], is_primary_producer: true} + {id: 2, name: 'Two', supplied_products: [3, 4]} + {id: 3, name: 'Three', supplied_products: [5, 6], sells: 'any'} + ] + + it 'loads enterprises as a hash', -> + enterprises = Enterprise.index() + $httpBackend.flush() + expect(enterprises).toEqual + 1: new Enterprise.Enterprise({id: 1, name: 'One', supplied_products: [1, 2], is_primary_producer: true}) + 2: new Enterprise.Enterprise({id: 2, name: 'Two', supplied_products: [3, 4]}) + 3: new Enterprise.Enterprise({id: 3, name: 'Three', supplied_products: [5, 6], sells: 'any'}) + + it 'reports its loadedness', -> + expect(Enterprise.loaded).toBe(false) + Enterprise.index() + $httpBackend.flush() + expect(Enterprise.loaded).toBe(true) + + it 'loads producers as an array', -> + Enterprise.index() + $httpBackend.flush() + expect(Enterprise.producer_enterprises).toEqual [new Enterprise.Enterprise({id: 1, name: 'One', supplied_products: [1, 2], is_primary_producer: true})] + + it 'loads hubs as an array', -> + Enterprise.index() + $httpBackend.flush() + expect(Enterprise.hub_enterprises).toEqual [new Enterprise.Enterprise({id: 3, name: 'Three', supplied_products: [5, 6], sells: 'any'})] + + it 'collates all supplied products', -> + enterprises = Enterprise.index() + $httpBackend.flush() + expect(Enterprise.supplied_products).toEqual [1, 2, 3, 4, 5, 6] + + it "finds supplied variants for an enterprise", -> + spyOn(Enterprise, 'variantsOf').and.returnValue(10) + Enterprise.index() + $httpBackend.flush() + expect(Enterprise.suppliedVariants(1)).toEqual [10, 10] + + describe "finding the variants of a product", -> + it "returns the master for products without variants", -> + p = + master_id: 1 + variants: [] + expect(Enterprise.variantsOf(p)).toEqual [1] + + it "returns the variant ids for products with variants", -> + p = + master_id: 1 + variants: [{id: 2}, {id: 3}] + expect(Enterprise.variantsOf(p)).toEqual [2, 3] + + it 'counts total variants supplied by an enterprise', -> + enterprise = + supplied_products: [ + {variants: []}, + {variants: []}, + {variants: [{}, {}, {}]} + ] + + expect(Enterprise.totalVariants(enterprise)).toEqual(5) + + it 'returns zero when enterprise is null', -> + expect(Enterprise.totalVariants(null)).toEqual(0) diff --git a/spec/javascripts/unit/admin/order_cycles/services/order_cycle_spec.js.coffee b/spec/javascripts/unit/admin/order_cycles/services/order_cycle_spec.js.coffee new file mode 100644 index 0000000000..18f07406d8 --- /dev/null +++ b/spec/javascripts/unit/admin/order_cycles/services/order_cycle_spec.js.coffee @@ -0,0 +1,520 @@ +describe 'OrderCycle service', -> + OrderCycle = null + $httpBackend = null + $window = null + + beforeEach -> + $window = {navigator: {userAgent: 'foo'}} + + module 'admin.orderCycles', ($provide)-> + $provide.value('$window', $window) + null + + inject ($injector, _$httpBackend_)-> + OrderCycle = $injector.get('OrderCycle') + $httpBackend = _$httpBackend_ + $httpBackend.whenGET('/admin/order_cycles/123.json').respond + id: 123 + name: 'Test Order Cycle' + coordinator_id: 456 + coordinator_fees: [] + exchanges: [ + {sender_id: 1, receiver_id: 456, incoming: true} + {sender_id: 456, receiver_id: 2, incoming: false} + ] + $httpBackend.whenGET('/admin/order_cycles/new.json').respond + id: 123 + name: 'New Order Cycle' + coordinator_id: 456 + coordinator_fees: [] + exchanges: [] + + it 'initialises order cycle', -> + expect(OrderCycle.order_cycle).toEqual {incoming_exchanges: [], outgoing_exchanges: []} + + it 'counts selected variants in an exchange', -> + result = OrderCycle.exchangeSelectedVariants({variants: {1: true, 2: false, 3: true}}) + expect(result).toEqual(2) + + describe "fetching exchange ids", -> + it "gets enterprise ids as ints", -> + OrderCycle.order_cycle.incoming_exchanges = [ + {enterprise_id: 1} + {enterprise_id: '2'} + ] + OrderCycle.order_cycle.outgoing_exchanges = [ + {enterprise_id: 3} + {enterprise_id: '4'} + ] + expect(OrderCycle.exchangeIds('incoming')).toEqual [1, 2] + + describe "checking for novel enterprises", -> + e1 = {id: 1} + e2 = {id: 2} + + beforeEach -> + OrderCycle.order_cycle.incoming_exchanges = [{enterprise_id: 1}] + OrderCycle.order_cycle.outgoing_exchanges = [{enterprise_id: 1}] + + it "detects novel suppliers", -> + expect(OrderCycle.novelSupplier(e1)).toBe false + expect(OrderCycle.novelSupplier(e2)).toBe true + + it "detects novel suppliers with enterprise as string id", -> + expect(OrderCycle.novelSupplier('1')).toBe false + expect(OrderCycle.novelSupplier('2')).toBe true + + it "detects novel distributors", -> + expect(OrderCycle.novelDistributor(e1)).toBe false + expect(OrderCycle.novelDistributor(e2)).toBe true + + it "detects novel distributors with enterprise as string id", -> + expect(OrderCycle.novelDistributor('1')).toBe false + expect(OrderCycle.novelDistributor('2')).toBe true + + + describe 'fetching the direction for an exchange', -> + it 'returns "incoming" for incoming exchanges', -> + exchange = {id: 1} + OrderCycle.order_cycle.incoming_exchanges = [exchange] + OrderCycle.order_cycle.outgoing_exchanges = [] + expect(OrderCycle.exchangeDirection(exchange)).toEqual 'incoming' + + it 'returns "outgoing" for outgoing exchanges', -> + exchange = {id: 1} + OrderCycle.order_cycle.incoming_exchanges = [] + OrderCycle.order_cycle.outgoing_exchanges = [exchange] + expect(OrderCycle.exchangeDirection(exchange)).toEqual 'outgoing' + + describe "setting exchange variants", -> + describe "when I have permissions to edit the variants", -> + beforeEach -> + OrderCycle.order_cycle["editable_variants_for_outgoing_exchanges"] = { 1: [1, 2, 3] } + + it "sets all variants to the provided value", -> + exchange = { enterprise_id: 1, incoming: false, variants: {2: false}} + OrderCycle.setExchangeVariants(exchange, [1, 2, 3], true) + expect(exchange.variants).toEqual {1: true, 2: true, 3: true} + + describe "when I don't have permissions to edit the variants", -> + beforeEach -> + OrderCycle.order_cycle["editable_variants_for_outgoing_exchanges"] = { 1: [] } + + it "does not change variants to the provided value", -> + exchange = { enterprise_id: 1, incoming: false, variants: {2: false}} + OrderCycle.setExchangeVariants(exchange, [1, 2, 3], true) + expect(exchange.variants).toEqual {2: false} + + describe 'adding suppliers', -> + exchange = null + + beforeEach -> + # Initialise OC + OrderCycle.new() + $httpBackend.flush() + + it 'adds the supplier to incoming exchanges', -> + OrderCycle.addSupplier('123') + expect(OrderCycle.order_cycle.incoming_exchanges).toEqual [ + {enterprise_id: '123', incoming: true, active: true, variants: {}, enterprise_fees: []} + ] + + describe 'adding distributors', -> + exchange = null + + beforeEach -> + # Initialise OC + OrderCycle.new() + $httpBackend.flush() + + it 'adds the distributor to outgoing exchanges', -> + OrderCycle.addDistributor('123') + expect(OrderCycle.order_cycle.outgoing_exchanges).toEqual [ + {enterprise_id: '123', incoming: false, active: true, variants: {}, enterprise_fees: []} + ] + + describe 'removing exchanges', -> + exchange = null + + beforeEach -> + spyOn(OrderCycle, 'removeDistributionOfVariant') + exchange = + enterprise_id: '123' + active: true + incoming: false + variants: {1: true, 2: false, 3: true} + enterprise_fees: [] + + describe "removing incoming exchanges", -> + beforeEach -> + exchange.incoming = true + OrderCycle.order_cycle.incoming_exchanges = [exchange] + + it 'removes the exchange', -> + OrderCycle.removeExchange(exchange) + expect(OrderCycle.order_cycle.incoming_exchanges).toEqual [] + + it 'removes distribution of all exchange variants', -> + OrderCycle.removeExchange(exchange) + expect(OrderCycle.removeDistributionOfVariant).toHaveBeenCalledWith('1') + expect(OrderCycle.removeDistributionOfVariant).not.toHaveBeenCalledWith('2') + expect(OrderCycle.removeDistributionOfVariant).toHaveBeenCalledWith('3') + + describe "removing outgoing exchanges", -> + beforeEach -> + exchange.incoming = false + OrderCycle.order_cycle.outgoing_exchanges = [exchange] + + it 'removes the exchange', -> + OrderCycle.removeExchange(exchange) + expect(OrderCycle.order_cycle.outgoing_exchanges).toEqual [] + + it "does not remove distribution of any variants", -> + OrderCycle.removeExchange(exchange) + expect(OrderCycle.removeDistributionOfVariant).not.toHaveBeenCalled() + + it 'adds coordinator fees', -> + # Initialise OC + OrderCycle.new() + $httpBackend.flush() + OrderCycle.addCoordinatorFee() + expect(OrderCycle.order_cycle.coordinator_fees).toEqual [{}] + + describe 'removing coordinator fees', -> + it 'removes a coordinator fee by index', -> + OrderCycle.order_cycle.coordinator_fees = [ + {id: 1} + {id: 2} + {id: 3} + ] + OrderCycle.removeCoordinatorFee(1) + expect(OrderCycle.order_cycle.coordinator_fees).toEqual [ + {id: 1} + {id: 3} + ] + + it 'adds exchange fees', -> + exchange = {enterprise_fees: []} + OrderCycle.addExchangeFee(exchange) + expect(exchange.enterprise_fees).toEqual [{}] + + describe 'removing exchange fees', -> + it 'removes an exchange fee by index', -> + exchange = + enterprise_fees: [ + {id: 1} + {id: 2} + {id: 3} + ] + OrderCycle.removeExchangeFee(exchange, 1) + expect(exchange.enterprise_fees).toEqual [ + {id: 1} + {id: 3} + ] + + it 'finds participating enterprise ids', -> + OrderCycle.order_cycle.incoming_exchanges = [ + {enterprise_id: 1} + {enterprise_id: 2} + ] + OrderCycle.order_cycle.outgoing_exchanges = [ + {enterprise_id: 2} + {enterprise_id: 3} + ] + expect(OrderCycle.participatingEnterpriseIds()).toEqual [1, 2, 3] + + describe 'fetching all variants supplied on incoming exchanges', -> + it 'collects variants from incoming exchanges', -> + OrderCycle.order_cycle.incoming_exchanges = [ + {variants: {1: true, 2: false}} + {variants: {3: false, 4: true}} + {variants: {5: true, 6: false}} + ] + expect(OrderCycle.incomingExchangesVariants()).toEqual [1, 4, 5] + + describe 'checking whether a product is supplied to the order cycle', -> + product_master_present = product_variant_present = product_master_absent = product_variant_absent = null + + beforeEach -> + product_master_present = + name: "Linseed (500g)" + master_id: 1 + variants: [] + product_variant_present = + name: "Linseed (500g)" + master_id: 2 + variants: [{id: 3}, {id: 4}] + product_master_absent = + name: "Linseed (500g)" + master_id: 5 + variants: [] + product_variant_absent = + name: "Linseed (500g)" + master_id: 6 + variants: [{id: 7}, {id: 8}] + + spyOn(OrderCycle, 'incomingExchangesVariants').and.returnValue([1, 3]) + + it 'returns true for products whose master is supplied', -> + expect(OrderCycle.productSuppliedToOrderCycle(product_master_present)).toBeTruthy() + + it 'returns true for products for whom a variant is supplied', -> + expect(OrderCycle.productSuppliedToOrderCycle(product_variant_present)).toBeTruthy() + + it 'returns false for products whose master is not supplied', -> + expect(OrderCycle.productSuppliedToOrderCycle(product_master_absent)).toBeFalsy() + + it 'returns false for products whose variants are not supplied', -> + expect(OrderCycle.productSuppliedToOrderCycle(product_variant_absent)).toBeFalsy() + + + describe 'checking whether a variant is supplied to the order cycle', -> + beforeEach -> + spyOn(OrderCycle, 'incomingExchangesVariants').and.returnValue([1, 3]) + + it 'returns true for variants that are supplied', -> + expect(OrderCycle.variantSuppliedToOrderCycle({id: 1})).toBeTruthy() + + it 'returns false for variants that are not supplied', -> + expect(OrderCycle.variantSuppliedToOrderCycle({id: 999})).toBeFalsy() + + + describe 'remove all distribution of a variant', -> + it 'removes the variant from every outgoing exchange', -> + OrderCycle.order_cycle.outgoing_exchanges = [ + {variants: {123: true, 234: true}} + {variants: {123: true, 333: true}} + ] + OrderCycle.removeDistributionOfVariant('123') + expect(OrderCycle.order_cycle.outgoing_exchanges).toEqual [ + {variants: {123: false, 234: true}} + {variants: {123: false, 333: true}} + ] + + describe 'loading an order cycle, reporting loadedness', -> + it 'reports its loadedness', -> + expect(OrderCycle.loaded).toBe(false) + OrderCycle.load('123') + $httpBackend.flush() + expect(OrderCycle.loaded).toBe(true) + + describe 'loading a new order cycle', -> + beforeEach -> + OrderCycle.new() + $httpBackend.flush() + + + it 'loads basic fields', -> + expect(OrderCycle.order_cycle.id).toEqual(123) + expect(OrderCycle.order_cycle.name).toEqual('New Order Cycle') + expect(OrderCycle.order_cycle.coordinator_id).toEqual(456) + + it 'initialises the incoming and outgoing exchanges', -> + expect(OrderCycle.order_cycle.incoming_exchanges).toEqual [] + expect(OrderCycle.order_cycle.outgoing_exchanges).toEqual [] + + it 'removes the original exchanges array', -> + expect(OrderCycle.order_cycle.exchanges).toBeUndefined() + + describe 'loading an existing order cycle', -> + beforeEach -> + OrderCycle.load('123') + $httpBackend.flush() + + it 'loads basic fields', -> + expect(OrderCycle.order_cycle.id).toEqual(123) + expect(OrderCycle.order_cycle.name).toEqual('Test Order Cycle') + expect(OrderCycle.order_cycle.coordinator_id).toEqual(456) + + it 'splits exchanges into incoming and outgoing', -> + expect(OrderCycle.order_cycle.incoming_exchanges).toEqual [ + sender_id: 1 + enterprise_id: 1 + incoming: true + active: true + ] + + expect(OrderCycle.order_cycle.outgoing_exchanges).toEqual [ + receiver_id: 2 + enterprise_id: 2 + incoming: false + active: true + ] + + it 'removes the original exchanges array', -> + expect(OrderCycle.order_cycle.exchanges).toBeUndefined() + + describe 'creating an order cycle', -> + beforeEach -> + spyOn(OrderCycle, 'confirmNoDistributors').and.returnValue true + + it 'redirects to the destination page on success', -> + OrderCycle.order_cycle = 'this is the order cycle' + spyOn(OrderCycle, 'dataForSubmit').and.returnValue('this is the submit data') + $httpBackend.expectPOST('/admin/order_cycles.json', { + order_cycle: 'this is the submit data' + }).respond {success: true} + + OrderCycle.create('/destination/page') + $httpBackend.flush() + expect($window.location).toEqual('/destination/page') + + it 'does not redirect on error', -> + OrderCycle.order_cycle = 'this is the order cycle' + spyOn(OrderCycle, 'dataForSubmit').and.returnValue('this is the submit data') + $httpBackend.expectPOST('/admin/order_cycles.json', { + order_cycle: 'this is the submit data' + }).respond 400, { errors: [] } + + OrderCycle.create('/destination/page') + $httpBackend.flush() + expect($window.location).toEqual(undefined) + + describe 'updating an order cycle', -> + beforeEach -> + spyOn(OrderCycle, 'confirmNoDistributors').and.returnValue true + + it 'redirects to the destination page on success', -> + form = jasmine.createSpyObj('order_cycle_form', ['$dirty', '$setPristine']) + OrderCycle.order_cycle = 'this is the order cycle' + spyOn(OrderCycle, 'dataForSubmit').and.returnValue('this is the submit data') + $httpBackend.expectPUT('/admin/order_cycles.json?reloading=1', { + order_cycle: 'this is the submit data' + }).respond {success: true} + + OrderCycle.update('/destination/page', form) + $httpBackend.flush() + expect($window.location).toEqual('/destination/page') + expect(form.$setPristine.calls.count()).toBe 1 + + it 'does not redirect on error', -> + OrderCycle.order_cycle = 'this is the order cycle' + spyOn(OrderCycle, 'dataForSubmit').and.returnValue('this is the submit data') + $httpBackend.expectPUT('/admin/order_cycles.json?reloading=1', { + order_cycle: 'this is the submit data' + }).respond 400, { errors: [] } + + OrderCycle.update('/destination/page') + $httpBackend.flush() + expect($window.location).toEqual(undefined) + + describe 'preparing data for form submission', -> + it 'calls all the methods', -> + OrderCycle.order_cycle = {foo: 'bar'} + spyOn(OrderCycle, 'removeInactiveExchanges') + spyOn(OrderCycle, 'translateCoordinatorFees') + spyOn(OrderCycle, 'translateExchangeFees') + OrderCycle.dataForSubmit() + expect(OrderCycle.removeInactiveExchanges).toHaveBeenCalled() + expect(OrderCycle.translateCoordinatorFees).toHaveBeenCalled() + expect(OrderCycle.translateExchangeFees).toHaveBeenCalled() + + it 'removes inactive exchanges', -> + data = + incoming_exchanges: [ + {enterprise_id: "1", active: false} + {enterprise_id: "2", active: true} + {enterprise_id: "3", active: false} + ] + outgoing_exchanges: [ + {enterprise_id: "4", active: true} + {enterprise_id: "5", active: false} + {enterprise_id: "6", active: true} + ] + + data = OrderCycle.removeInactiveExchanges(data) + + expect(data.incoming_exchanges).toEqual [ + {enterprise_id: "2", active: true} + ] + expect(data.outgoing_exchanges).toEqual [ + {enterprise_id: "4", active: true} + {enterprise_id: "6", active: true} + ] + + it 'converts coordinator fees into a list of ids', -> + order_cycle = + coordinator_fees: [ + {id: 1} + {id: 2} + ] + + data = OrderCycle.translateCoordinatorFees(order_cycle) + + expect(data.coordinator_fees).toBeUndefined() + expect(data.coordinator_fee_ids).toEqual [1, 2] + + it "preserves original data when converting coordinator fees", -> + OrderCycle.order_cycle = + coordinator_fees: [ + {id: 1} + {id: 2} + ] + + data = OrderCycle.deepCopy() + data = OrderCycle.translateCoordinatorFees(data) + + expect(OrderCycle.order_cycle.coordinator_fees).toEqual [{id: 1}, {id: 2}] + expect(OrderCycle.order_cycle.coordinator_fee_ids).toBeUndefined() + + describe "converting exchange fees into a list of ids", -> + order_cycle = null + data = null + + beforeEach -> + order_cycle = + incoming_exchanges: [ + enterprise_fees: [ + {id: 1} + {id: 2} + ] + ] + outgoing_exchanges: [ + enterprise_fees: [ + {id: 3} + {id: 4} + ] + ] + OrderCycle.order_cycle = order_cycle + + data = OrderCycle.deepCopy() + data = OrderCycle.translateExchangeFees(data) + + it 'converts exchange fees into a list of ids', -> + expect(data.incoming_exchanges[0].enterprise_fees).toBeUndefined() + expect(data.outgoing_exchanges[0].enterprise_fees).toBeUndefined() + expect(data.incoming_exchanges[0].enterprise_fee_ids).toEqual [1, 2] + expect(data.outgoing_exchanges[0].enterprise_fee_ids).toEqual [3, 4] + + it "preserves original data when converting exchange fees", -> + expect(order_cycle.incoming_exchanges[0].enterprise_fees).toEqual [{id: 1}, {id: 2}] + expect(order_cycle.outgoing_exchanges[0].enterprise_fees).toEqual [{id: 3}, {id: 4}] + expect(order_cycle.incoming_exchanges[0].enterprise_fee_ids).toBeUndefined() + expect(order_cycle.outgoing_exchanges[0].enterprise_fee_ids).toBeUndefined() + + describe "confirming when there are no distributors", -> + order_cycle_with_exchanges = order_cycle_without_exchanges = null + + beforeEach -> + order_cycle_with_exchanges = + outgoing_exchanges: [{}] + order_cycle_without_exchanges = + outgoing_exchanges: [] + + it "returns true when there are distributors", -> + spyOn(window, 'confirm') + OrderCycle.order_cycle = order_cycle_with_exchanges + expect(OrderCycle.confirmNoDistributors()).toBe true + expect(window.confirm).not.toHaveBeenCalled() + + it "returns true when there are no distributors but the user confirms", -> + spyOn(window, 'confirm').and.returnValue(true) + OrderCycle.order_cycle = order_cycle_without_exchanges + expect(OrderCycle.confirmNoDistributors()).toBe true + expect(window.confirm).toHaveBeenCalled() + + it "returns false when there are no distributors and the user does not confirm", -> + spyOn(window, 'confirm').and.returnValue(false) + OrderCycle.order_cycle = order_cycle_without_exchanges + expect(OrderCycle.confirmNoDistributors()).toBe false + expect(window.confirm).toHaveBeenCalled() diff --git a/spec/javascripts/unit/order_cycle_spec.js.coffee b/spec/javascripts/unit/order_cycle_spec.js.coffee deleted file mode 100644 index 6c6f3440e6..0000000000 --- a/spec/javascripts/unit/order_cycle_spec.js.coffee +++ /dev/null @@ -1,968 +0,0 @@ -describe 'OrderCycle controllers', -> - - describe 'AdminCreateOrderCycleCtrl', -> - ctrl = null - scope = null - event = null - OrderCycle = null - Enterprise = null - EnterpriseFee = null - - beforeEach -> - scope = - order_cycle_form: jasmine.createSpyObj('order_cycle_form', ['$dirty']) - $watch: jasmine.createSpy('$watch') - event = - preventDefault: jasmine.createSpy('preventDefault') - OrderCycle = - exchangeSelectedVariants: jasmine.createSpy('exchangeSelectedVariants').and.returnValue('variants selected') - productSuppliedToOrderCycle: jasmine.createSpy('productSuppliedToOrderCycle').and.returnValue('product supplied') - variantSuppliedToOrderCycle: jasmine.createSpy('variantSuppliedToOrderCycle').and.returnValue('variant supplied') - exchangeDirection: jasmine.createSpy('exchangeDirection').and.returnValue('exchange direction') - toggleProducts: jasmine.createSpy('toggleProducts') - setExchangeVariants: jasmine.createSpy('setExchangeVariants') - addSupplier: jasmine.createSpy('addSupplier') - addDistributor: jasmine.createSpy('addDistributor') - removeExchange: jasmine.createSpy('removeExchange') - addCoordinatorFee: jasmine.createSpy('addCoordinatorFee') - removeCoordinatorFee: jasmine.createSpy('removeCoordinatorFee') - addExchangeFee: jasmine.createSpy('addExchangeFee') - removeExchangeFee: jasmine.createSpy('removeExchangeFee') - removeDistributionOfVariant: jasmine.createSpy('removeDistributionOfVariant') - create: jasmine.createSpy('create') - new: jasmine.createSpy('new').and.returnValue "my order cycle" - Enterprise = - index: jasmine.createSpy('index').and.returnValue('enterprises list') - supplied_products: 'supplied products' - suppliedVariants: jasmine.createSpy('suppliedVariants').and.returnValue('supplied variants') - totalVariants: jasmine.createSpy('totalVariants').and.returnValue('variants total') - EnterpriseFee = - index: jasmine.createSpy('index').and.returnValue('enterprise fees list') - forEnterprise: jasmine.createSpy('forEnterprise').and.returnValue('enterprise fees for enterprise') - ocInstance = {} - - module('admin.orderCycles') - inject ($controller) -> - ctrl = $controller 'AdminCreateOrderCycleCtrl', {$scope: scope, OrderCycle: OrderCycle, Enterprise: Enterprise, EnterpriseFee: EnterpriseFee, ocInstance: ocInstance} - - - it 'Loads enterprises and supplied products', -> - expect(Enterprise.index).toHaveBeenCalled() - expect(scope.enterprises).toEqual('enterprises list') - expect(scope.supplied_products).toEqual('supplied products') - - it 'Loads enterprise fees', -> - expect(EnterpriseFee.index).toHaveBeenCalled() - expect(scope.enterprise_fees).toEqual('enterprise fees list') - - it 'Loads order cycles', -> - expect(scope.order_cycle).toEqual('my order cycle') - - describe 'Reporting when all resources are loaded', -> - beforeEach inject (RequestMonitor) -> - RequestMonitor.loading = false - Enterprise.loaded = true - EnterpriseFee.loaded = true - OrderCycle.loaded = true - - it 'returns true when all resources are loaded', -> - expect(scope.loaded()).toBe(true) - - it 'returns false otherwise', -> - EnterpriseFee.loaded = false - expect(scope.loaded()).toBe(false) - - it "delegates suppliedVariants to Enterprise", -> - expect(scope.suppliedVariants('enterprise_id')).toEqual('supplied variants') - expect(Enterprise.suppliedVariants).toHaveBeenCalledWith('enterprise_id') - - it 'Delegates exchangeSelectedVariants to OrderCycle', -> - expect(scope.exchangeSelectedVariants('exchange')).toEqual('variants selected') - expect(OrderCycle.exchangeSelectedVariants).toHaveBeenCalledWith('exchange') - - it "delegates setExchangeVariants to OrderCycle", -> - scope.setExchangeVariants('exchange', 'variants', 'selected') - expect(OrderCycle.setExchangeVariants).toHaveBeenCalledWith('exchange', 'variants', 'selected') - - it 'Delegates enterpriseTotalVariants to Enterprise', -> - expect(scope.enterpriseTotalVariants('enterprise')).toEqual('variants total') - expect(Enterprise.totalVariants).toHaveBeenCalledWith('enterprise') - - it 'Delegates productSuppliedToOrderCycle to OrderCycle', -> - expect(scope.productSuppliedToOrderCycle('product')).toEqual('product supplied') - expect(OrderCycle.productSuppliedToOrderCycle).toHaveBeenCalledWith('product') - - it 'Delegates variantSuppliedToOrderCycle to OrderCycle', -> - expect(scope.variantSuppliedToOrderCycle('variant')).toEqual('variant supplied') - expect(OrderCycle.variantSuppliedToOrderCycle).toHaveBeenCalledWith('variant') - - it 'Delegates exchangeDirection to OrderCycle', -> - expect(scope.exchangeDirection('exchange')).toEqual('exchange direction') - expect(OrderCycle.exchangeDirection).toHaveBeenCalledWith('exchange') - - it 'Finds enterprises participating in the order cycle that have fees', -> - scope.enterprises = - 1: {id: 1, name: 'Eaterprises'} - 2: {id: 2, name: 'Pepper Tree Place'} - 3: {id: 3, name: 'South East'} - OrderCycle.participatingEnterpriseIds = jasmine.createSpy('participatingEnterpriseIds').and.returnValue([2]) - EnterpriseFee.enterprise_fees = [ {enterprise_id: 2} ] # Pepper Tree Place has a fee - expect(scope.enterprisesWithFees()).toEqual([ - {id: 2, name: 'Pepper Tree Place'} - ]) - - it 'Delegates enterpriseFeesForEnterprise to EnterpriseFee', -> - scope.enterpriseFeesForEnterprise('123') - expect(EnterpriseFee.forEnterprise).toHaveBeenCalledWith(123) - - it 'Adds order cycle suppliers', -> - scope.new_supplier_id = 'new supplier id' - scope.addSupplier(event) - expect(event.preventDefault).toHaveBeenCalled() - expect(OrderCycle.addSupplier).toHaveBeenCalledWith('new supplier id') - - it 'Adds order cycle distributors', -> - scope.new_distributor_id = 'new distributor id' - scope.addDistributor(event) - expect(event.preventDefault).toHaveBeenCalled() - expect(OrderCycle.addDistributor).toHaveBeenCalledWith('new distributor id') - - it 'Removes order cycle exchanges', -> - scope.removeExchange(event, 'exchange') - expect(event.preventDefault).toHaveBeenCalled() - expect(OrderCycle.removeExchange).toHaveBeenCalledWith('exchange') - - it 'Adds coordinator fees', -> - scope.addCoordinatorFee(event) - expect(event.preventDefault).toHaveBeenCalled() - expect(OrderCycle.addCoordinatorFee).toHaveBeenCalled() - - it 'Removes coordinator fees', -> - scope.removeCoordinatorFee(event, 0) - expect(event.preventDefault).toHaveBeenCalled() - expect(OrderCycle.removeCoordinatorFee).toHaveBeenCalledWith(0) - - it 'Adds exchange fees', -> - scope.addExchangeFee(event) - expect(event.preventDefault).toHaveBeenCalled() - expect(OrderCycle.addExchangeFee).toHaveBeenCalled() - - it 'Removes exchange fees', -> - scope.removeExchangeFee(event, 'exchange', 0) - expect(event.preventDefault).toHaveBeenCalled() - expect(OrderCycle.removeExchangeFee).toHaveBeenCalledWith('exchange', 0) - - it 'Removes distribution of a variant', -> - scope.removeDistributionOfVariant('variant') - expect(OrderCycle.removeDistributionOfVariant).toHaveBeenCalledWith('variant') - - it 'Submits the order cycle via OrderCycle create', -> - eventMock = {preventDefault: jasmine.createSpy()} - scope.submit(eventMock,'/admin/order_cycles') - expect(eventMock.preventDefault).toHaveBeenCalled() - expect(OrderCycle.create).toHaveBeenCalledWith('/admin/order_cycles') - - describe 'AdminEditOrderCycleCtrl', -> - ctrl = null - scope = null - event = null - location = null - OrderCycle = null - Enterprise = null - EnterpriseFee = null - - beforeEach -> - scope = - order_cycle_form: jasmine.createSpyObj('order_cycle_form', ['$dirty', '$setPristine']) - $watch: jasmine.createSpy('$watch') - event = - preventDefault: jasmine.createSpy('preventDefault') - location = - absUrl: -> - 'example.com/admin/order_cycles/27/edit' - OrderCycle = - load: jasmine.createSpy('load') - exchangeSelectedVariants: jasmine.createSpy('exchangeSelectedVariants').and.returnValue('variants selected') - productSuppliedToOrderCycle: jasmine.createSpy('productSuppliedToOrderCycle').and.returnValue('product supplied') - variantSuppliedToOrderCycle: jasmine.createSpy('variantSuppliedToOrderCycle').and.returnValue('variant supplied') - exchangeDirection: jasmine.createSpy('exchangeDirection').and.returnValue('exchange direction') - toggleProducts: jasmine.createSpy('toggleProducts') - setExchangeVariants: jasmine.createSpy('setExchangeVariants') - addSupplier: jasmine.createSpy('addSupplier') - addDistributor: jasmine.createSpy('addDistributor') - removeExchange: jasmine.createSpy('removeExchange') - addCoordinatorFee: jasmine.createSpy('addCoordinatorFee') - removeCoordinatorFee: jasmine.createSpy('removeCoordinatorFee') - addExchangeFee: jasmine.createSpy('addExchangeFee') - removeExchangeFee: jasmine.createSpy('removeExchangeFee') - removeDistributionOfVariant: jasmine.createSpy('removeDistributionOfVariant') - update: jasmine.createSpy('update') - Enterprise = - index: jasmine.createSpy('index').and.returnValue('enterprises list') - supplied_products: 'supplied products' - suppliedVariants: jasmine.createSpy('suppliedVariants').and.returnValue('supplied variants') - totalVariants: jasmine.createSpy('totalVariants').and.returnValue('variants total') - EnterpriseFee = - index: jasmine.createSpy('index').and.returnValue('enterprise fees list') - forEnterprise: jasmine.createSpy('forEnterprise').and.returnValue('enterprise fees for enterprise') - - module('admin.orderCycles') - inject ($controller) -> - ctrl = $controller 'AdminEditOrderCycleCtrl', {$scope: scope, $location: location, OrderCycle: OrderCycle, Enterprise: Enterprise, EnterpriseFee: EnterpriseFee} - - it 'Loads enterprises and supplied products', -> - expect(Enterprise.index).toHaveBeenCalled() - expect(scope.enterprises).toEqual('enterprises list') - expect(scope.supplied_products).toEqual('supplied products') - - it 'Loads enterprise fees', -> - expect(EnterpriseFee.index).toHaveBeenCalled() - expect(scope.enterprise_fees).toEqual('enterprise fees list') - - it 'Loads order cycles', -> - expect(OrderCycle.load).toHaveBeenCalledWith('27') - - describe 'Reporting when all resources are loaded', -> - beforeEach inject (RequestMonitor) -> - RequestMonitor.loading = false - Enterprise.loaded = true - EnterpriseFee.loaded = true - OrderCycle.loaded = true - - it 'returns true when all resources are loaded', -> - expect(scope.loaded()).toBe(true) - - it 'returns false otherwise', -> - EnterpriseFee.loaded = false - expect(scope.loaded()).toBe(false) - - it "delegates suppliedVariants to Enterprise", -> - expect(scope.suppliedVariants('enterprise_id')).toEqual('supplied variants') - expect(Enterprise.suppliedVariants).toHaveBeenCalledWith('enterprise_id') - - it 'Delegates exchangeSelectedVariants to OrderCycle', -> - expect(scope.exchangeSelectedVariants('exchange')).toEqual('variants selected') - expect(OrderCycle.exchangeSelectedVariants).toHaveBeenCalledWith('exchange') - - it "delegates setExchangeVariants to OrderCycle", -> - scope.setExchangeVariants('exchange', 'variants', 'selected') - expect(OrderCycle.setExchangeVariants).toHaveBeenCalledWith('exchange', 'variants', 'selected') - - it 'Delegates totalVariants to Enterprise', -> - expect(scope.enterpriseTotalVariants('enterprise')).toEqual('variants total') - expect(Enterprise.totalVariants).toHaveBeenCalledWith('enterprise') - - it 'Delegates productSuppliedToOrderCycle to OrderCycle', -> - expect(scope.productSuppliedToOrderCycle('product')).toEqual('product supplied') - expect(OrderCycle.productSuppliedToOrderCycle).toHaveBeenCalledWith('product') - - it 'Delegates variantSuppliedToOrderCycle to OrderCycle', -> - expect(scope.variantSuppliedToOrderCycle('variant')).toEqual('variant supplied') - expect(OrderCycle.variantSuppliedToOrderCycle).toHaveBeenCalledWith('variant') - - it 'Delegates exchangeDirection to OrderCycle', -> - expect(scope.exchangeDirection('exchange')).toEqual('exchange direction') - expect(OrderCycle.exchangeDirection).toHaveBeenCalledWith('exchange') - - it 'Finds enterprises participating in the order cycle that have fees', -> - scope.enterprises = - 1: {id: 1, name: 'Eaterprises'} - 2: {id: 2, name: 'Pepper Tree Place'} - 3: {id: 3, name: 'South East'} - OrderCycle.participatingEnterpriseIds = jasmine.createSpy('participatingEnterpriseIds').and.returnValue([2]) - EnterpriseFee.enterprise_fees = [ {enterprise_id: 2} ] # Pepper Tree Place has a fee - expect(scope.enterprisesWithFees()).toEqual([ - {id: 2, name: 'Pepper Tree Place'} - ]) - - it 'Delegates enterpriseFeesForEnterprise to EnterpriseFee', -> - scope.enterpriseFeesForEnterprise('123') - expect(EnterpriseFee.forEnterprise).toHaveBeenCalledWith(123) - - it 'Adds order cycle suppliers', -> - scope.new_supplier_id = 'new supplier id' - scope.addSupplier(event) - expect(event.preventDefault).toHaveBeenCalled() - expect(OrderCycle.addSupplier).toHaveBeenCalledWith('new supplier id') - - it 'Adds order cycle distributors', -> - scope.new_distributor_id = 'new distributor id' - scope.addDistributor(event) - expect(event.preventDefault).toHaveBeenCalled() - expect(OrderCycle.addDistributor).toHaveBeenCalledWith('new distributor id') - - it 'Removes order cycle exchanges', -> - scope.removeExchange(event, 'exchange') - expect(event.preventDefault).toHaveBeenCalled() - expect(OrderCycle.removeExchange).toHaveBeenCalledWith('exchange') - expect(scope.order_cycle_form.$dirty).toEqual true - - it 'Adds coordinator fees', -> - scope.addCoordinatorFee(event) - expect(event.preventDefault).toHaveBeenCalled() - expect(OrderCycle.addCoordinatorFee).toHaveBeenCalled() - - it 'Removes coordinator fees', -> - scope.removeCoordinatorFee(event, 0) - expect(event.preventDefault).toHaveBeenCalled() - expect(OrderCycle.removeCoordinatorFee).toHaveBeenCalledWith(0) - expect(scope.order_cycle_form.$dirty).toEqual true - - it 'Adds exchange fees', -> - scope.addExchangeFee(event) - expect(event.preventDefault).toHaveBeenCalled() - expect(OrderCycle.addExchangeFee).toHaveBeenCalled() - - it 'Removes exchange fees', -> - scope.removeExchangeFee(event, 'exchange', 0) - expect(event.preventDefault).toHaveBeenCalled() - expect(OrderCycle.removeExchangeFee).toHaveBeenCalledWith('exchange', 0) - expect(scope.order_cycle_form.$dirty).toEqual true - - it 'Removes distribution of a variant', -> - scope.removeDistributionOfVariant('variant') - expect(OrderCycle.removeDistributionOfVariant).toHaveBeenCalledWith('variant') - - it 'Submits the order cycle via OrderCycle update', -> - eventMock = {preventDefault: jasmine.createSpy()} - scope.submit(eventMock,'/admin/order_cycles') - expect(eventMock.preventDefault).toHaveBeenCalled() - expect(OrderCycle.update).toHaveBeenCalledWith('/admin/order_cycles', scope.order_cycle_form) - - -describe 'OrderCycle services', -> - describe 'Enterprise service', -> - $httpBackend = null - Enterprise = null - - beforeEach -> - module 'admin.orderCycles' - inject ($injector, _$httpBackend_)-> - Enterprise = $injector.get('Enterprise') - $httpBackend = _$httpBackend_ - $httpBackend.whenGET('/admin/enterprises/for_order_cycle.json').respond [ - {id: 1, name: 'One', supplied_products: [1, 2], is_primary_producer: true} - {id: 2, name: 'Two', supplied_products: [3, 4]} - {id: 3, name: 'Three', supplied_products: [5, 6], sells: 'any'} - ] - - it 'loads enterprises as a hash', -> - enterprises = Enterprise.index() - $httpBackend.flush() - expect(enterprises).toEqual - 1: new Enterprise.Enterprise({id: 1, name: 'One', supplied_products: [1, 2], is_primary_producer: true}) - 2: new Enterprise.Enterprise({id: 2, name: 'Two', supplied_products: [3, 4]}) - 3: new Enterprise.Enterprise({id: 3, name: 'Three', supplied_products: [5, 6], sells: 'any'}) - - it 'reports its loadedness', -> - expect(Enterprise.loaded).toBe(false) - Enterprise.index() - $httpBackend.flush() - expect(Enterprise.loaded).toBe(true) - - it 'loads producers as an array', -> - Enterprise.index() - $httpBackend.flush() - expect(Enterprise.producer_enterprises).toEqual [new Enterprise.Enterprise({id: 1, name: 'One', supplied_products: [1, 2], is_primary_producer: true})] - - it 'loads hubs as an array', -> - Enterprise.index() - $httpBackend.flush() - expect(Enterprise.hub_enterprises).toEqual [new Enterprise.Enterprise({id: 3, name: 'Three', supplied_products: [5, 6], sells: 'any'})] - - it 'collates all supplied products', -> - enterprises = Enterprise.index() - $httpBackend.flush() - expect(Enterprise.supplied_products).toEqual [1, 2, 3, 4, 5, 6] - - it "finds supplied variants for an enterprise", -> - spyOn(Enterprise, 'variantsOf').and.returnValue(10) - Enterprise.index() - $httpBackend.flush() - expect(Enterprise.suppliedVariants(1)).toEqual [10, 10] - - describe "finding the variants of a product", -> - it "returns the master for products without variants", -> - p = - master_id: 1 - variants: [] - expect(Enterprise.variantsOf(p)).toEqual [1] - - it "returns the variant ids for products with variants", -> - p = - master_id: 1 - variants: [{id: 2}, {id: 3}] - expect(Enterprise.variantsOf(p)).toEqual [2, 3] - - it 'counts total variants supplied by an enterprise', -> - enterprise = - supplied_products: [ - {variants: []}, - {variants: []}, - {variants: [{}, {}, {}]} - ] - - expect(Enterprise.totalVariants(enterprise)).toEqual(5) - - it 'returns zero when enterprise is null', -> - expect(Enterprise.totalVariants(null)).toEqual(0) - - describe 'EnterpriseFee service', -> - $httpBackend = null - EnterpriseFee = null - - beforeEach -> - module 'admin.orderCycles' - inject ($injector, _$httpBackend_)-> - EnterpriseFee = $injector.get('EnterpriseFee') - $httpBackend = _$httpBackend_ - $httpBackend.whenGET('/admin/enterprise_fees/for_order_cycle.json').respond [ - {id: 1, name: "Yayfee", enterprise_id: 1} - {id: 2, name: "FeeTwo", enterprise_id: 2} - ] - - it 'loads enterprise fees', -> - enterprise_fees = EnterpriseFee.index() - $httpBackend.flush() - expected_fees = [ - new EnterpriseFee.EnterpriseFee({id: 1, name: "Yayfee", enterprise_id: 1}) - new EnterpriseFee.EnterpriseFee({id: 2, name: "FeeTwo", enterprise_id: 2}) - ] - for fee, i in enterprise_fees - expect(fee.id).toEqual(expected_fees[i].id) - - it 'reports its loadedness', -> - expect(EnterpriseFee.loaded).toBe(false) - EnterpriseFee.index() - $httpBackend.flush() - expect(EnterpriseFee.loaded).toBe(true) - - it 'returns enterprise fees for an enterprise', -> - all_enterprise_fees = EnterpriseFee.index() - $httpBackend.flush() - enterprise_fees = EnterpriseFee.forEnterprise(1) - expect(enterprise_fees).toEqual [ - new EnterpriseFee.EnterpriseFee({id: 1, name: "Yayfee", enterprise_id: 1}) - ] - - - describe 'OrderCycle service', -> - OrderCycle = null - $httpBackend = null - $window = null - - beforeEach -> - $window = {navigator: {userAgent: 'foo'}} - - module 'admin.orderCycles', ($provide)-> - $provide.value('$window', $window) - null - - inject ($injector, _$httpBackend_)-> - OrderCycle = $injector.get('OrderCycle') - $httpBackend = _$httpBackend_ - $httpBackend.whenGET('/admin/order_cycles/123.json').respond - id: 123 - name: 'Test Order Cycle' - coordinator_id: 456 - coordinator_fees: [] - exchanges: [ - {sender_id: 1, receiver_id: 456, incoming: true} - {sender_id: 456, receiver_id: 2, incoming: false} - ] - $httpBackend.whenGET('/admin/order_cycles/new.json').respond - id: 123 - name: 'New Order Cycle' - coordinator_id: 456 - coordinator_fees: [] - exchanges: [] - - it 'initialises order cycle', -> - expect(OrderCycle.order_cycle).toEqual {incoming_exchanges: [], outgoing_exchanges: []} - - it 'counts selected variants in an exchange', -> - result = OrderCycle.exchangeSelectedVariants({variants: {1: true, 2: false, 3: true}}) - expect(result).toEqual(2) - - describe "fetching exchange ids", -> - it "gets enterprise ids as ints", -> - OrderCycle.order_cycle.incoming_exchanges = [ - {enterprise_id: 1} - {enterprise_id: '2'} - ] - OrderCycle.order_cycle.outgoing_exchanges = [ - {enterprise_id: 3} - {enterprise_id: '4'} - ] - expect(OrderCycle.exchangeIds('incoming')).toEqual [1, 2] - - describe "checking for novel enterprises", -> - e1 = {id: 1} - e2 = {id: 2} - - beforeEach -> - OrderCycle.order_cycle.incoming_exchanges = [{enterprise_id: 1}] - OrderCycle.order_cycle.outgoing_exchanges = [{enterprise_id: 1}] - - it "detects novel suppliers", -> - expect(OrderCycle.novelSupplier(e1)).toBe false - expect(OrderCycle.novelSupplier(e2)).toBe true - - it "detects novel suppliers with enterprise as string id", -> - expect(OrderCycle.novelSupplier('1')).toBe false - expect(OrderCycle.novelSupplier('2')).toBe true - - it "detects novel distributors", -> - expect(OrderCycle.novelDistributor(e1)).toBe false - expect(OrderCycle.novelDistributor(e2)).toBe true - - it "detects novel distributors with enterprise as string id", -> - expect(OrderCycle.novelDistributor('1')).toBe false - expect(OrderCycle.novelDistributor('2')).toBe true - - - describe 'fetching the direction for an exchange', -> - it 'returns "incoming" for incoming exchanges', -> - exchange = {id: 1} - OrderCycle.order_cycle.incoming_exchanges = [exchange] - OrderCycle.order_cycle.outgoing_exchanges = [] - expect(OrderCycle.exchangeDirection(exchange)).toEqual 'incoming' - - it 'returns "outgoing" for outgoing exchanges', -> - exchange = {id: 1} - OrderCycle.order_cycle.incoming_exchanges = [] - OrderCycle.order_cycle.outgoing_exchanges = [exchange] - expect(OrderCycle.exchangeDirection(exchange)).toEqual 'outgoing' - - describe "setting exchange variants", -> - describe "when I have permissions to edit the variants", -> - beforeEach -> - OrderCycle.order_cycle["editable_variants_for_outgoing_exchanges"] = { 1: [1, 2, 3] } - - it "sets all variants to the provided value", -> - exchange = { enterprise_id: 1, incoming: false, variants: {2: false}} - OrderCycle.setExchangeVariants(exchange, [1, 2, 3], true) - expect(exchange.variants).toEqual {1: true, 2: true, 3: true} - - describe "when I don't have permissions to edit the variants", -> - beforeEach -> - OrderCycle.order_cycle["editable_variants_for_outgoing_exchanges"] = { 1: [] } - - it "does not change variants to the provided value", -> - exchange = { enterprise_id: 1, incoming: false, variants: {2: false}} - OrderCycle.setExchangeVariants(exchange, [1, 2, 3], true) - expect(exchange.variants).toEqual {2: false} - - describe 'adding suppliers', -> - exchange = null - - beforeEach -> - # Initialise OC - OrderCycle.new() - $httpBackend.flush() - - it 'adds the supplier to incoming exchanges', -> - OrderCycle.addSupplier('123') - expect(OrderCycle.order_cycle.incoming_exchanges).toEqual [ - {enterprise_id: '123', incoming: true, active: true, variants: {}, enterprise_fees: []} - ] - - describe 'adding distributors', -> - exchange = null - - beforeEach -> - # Initialise OC - OrderCycle.new() - $httpBackend.flush() - - it 'adds the distributor to outgoing exchanges', -> - OrderCycle.addDistributor('123') - expect(OrderCycle.order_cycle.outgoing_exchanges).toEqual [ - {enterprise_id: '123', incoming: false, active: true, variants: {}, enterprise_fees: []} - ] - - describe 'removing exchanges', -> - exchange = null - - beforeEach -> - spyOn(OrderCycle, 'removeDistributionOfVariant') - exchange = - enterprise_id: '123' - active: true - incoming: false - variants: {1: true, 2: false, 3: true} - enterprise_fees: [] - - describe "removing incoming exchanges", -> - beforeEach -> - exchange.incoming = true - OrderCycle.order_cycle.incoming_exchanges = [exchange] - - it 'removes the exchange', -> - OrderCycle.removeExchange(exchange) - expect(OrderCycle.order_cycle.incoming_exchanges).toEqual [] - - it 'removes distribution of all exchange variants', -> - OrderCycle.removeExchange(exchange) - expect(OrderCycle.removeDistributionOfVariant).toHaveBeenCalledWith('1') - expect(OrderCycle.removeDistributionOfVariant).not.toHaveBeenCalledWith('2') - expect(OrderCycle.removeDistributionOfVariant).toHaveBeenCalledWith('3') - - describe "removing outgoing exchanges", -> - beforeEach -> - exchange.incoming = false - OrderCycle.order_cycle.outgoing_exchanges = [exchange] - - it 'removes the exchange', -> - OrderCycle.removeExchange(exchange) - expect(OrderCycle.order_cycle.outgoing_exchanges).toEqual [] - - it "does not remove distribution of any variants", -> - OrderCycle.removeExchange(exchange) - expect(OrderCycle.removeDistributionOfVariant).not.toHaveBeenCalled() - - it 'adds coordinator fees', -> - # Initialise OC - OrderCycle.new() - $httpBackend.flush() - OrderCycle.addCoordinatorFee() - expect(OrderCycle.order_cycle.coordinator_fees).toEqual [{}] - - describe 'removing coordinator fees', -> - it 'removes a coordinator fee by index', -> - OrderCycle.order_cycle.coordinator_fees = [ - {id: 1} - {id: 2} - {id: 3} - ] - OrderCycle.removeCoordinatorFee(1) - expect(OrderCycle.order_cycle.coordinator_fees).toEqual [ - {id: 1} - {id: 3} - ] - - it 'adds exchange fees', -> - exchange = {enterprise_fees: []} - OrderCycle.addExchangeFee(exchange) - expect(exchange.enterprise_fees).toEqual [{}] - - describe 'removing exchange fees', -> - it 'removes an exchange fee by index', -> - exchange = - enterprise_fees: [ - {id: 1} - {id: 2} - {id: 3} - ] - OrderCycle.removeExchangeFee(exchange, 1) - expect(exchange.enterprise_fees).toEqual [ - {id: 1} - {id: 3} - ] - - it 'finds participating enterprise ids', -> - OrderCycle.order_cycle.incoming_exchanges = [ - {enterprise_id: 1} - {enterprise_id: 2} - ] - OrderCycle.order_cycle.outgoing_exchanges = [ - {enterprise_id: 2} - {enterprise_id: 3} - ] - expect(OrderCycle.participatingEnterpriseIds()).toEqual [1, 2, 3] - - describe 'fetching all variants supplied on incoming exchanges', -> - it 'collects variants from incoming exchanges', -> - OrderCycle.order_cycle.incoming_exchanges = [ - {variants: {1: true, 2: false}} - {variants: {3: false, 4: true}} - {variants: {5: true, 6: false}} - ] - expect(OrderCycle.incomingExchangesVariants()).toEqual [1, 4, 5] - - describe 'checking whether a product is supplied to the order cycle', -> - product_master_present = product_variant_present = product_master_absent = product_variant_absent = null - - beforeEach -> - product_master_present = - name: "Linseed (500g)" - master_id: 1 - variants: [] - product_variant_present = - name: "Linseed (500g)" - master_id: 2 - variants: [{id: 3}, {id: 4}] - product_master_absent = - name: "Linseed (500g)" - master_id: 5 - variants: [] - product_variant_absent = - name: "Linseed (500g)" - master_id: 6 - variants: [{id: 7}, {id: 8}] - - spyOn(OrderCycle, 'incomingExchangesVariants').and.returnValue([1, 3]) - - it 'returns true for products whose master is supplied', -> - expect(OrderCycle.productSuppliedToOrderCycle(product_master_present)).toBeTruthy() - - it 'returns true for products for whom a variant is supplied', -> - expect(OrderCycle.productSuppliedToOrderCycle(product_variant_present)).toBeTruthy() - - it 'returns false for products whose master is not supplied', -> - expect(OrderCycle.productSuppliedToOrderCycle(product_master_absent)).toBeFalsy() - - it 'returns false for products whose variants are not supplied', -> - expect(OrderCycle.productSuppliedToOrderCycle(product_variant_absent)).toBeFalsy() - - - describe 'checking whether a variant is supplied to the order cycle', -> - beforeEach -> - spyOn(OrderCycle, 'incomingExchangesVariants').and.returnValue([1, 3]) - - it 'returns true for variants that are supplied', -> - expect(OrderCycle.variantSuppliedToOrderCycle({id: 1})).toBeTruthy() - - it 'returns false for variants that are not supplied', -> - expect(OrderCycle.variantSuppliedToOrderCycle({id: 999})).toBeFalsy() - - - describe 'remove all distribution of a variant', -> - it 'removes the variant from every outgoing exchange', -> - OrderCycle.order_cycle.outgoing_exchanges = [ - {variants: {123: true, 234: true}} - {variants: {123: true, 333: true}} - ] - OrderCycle.removeDistributionOfVariant('123') - expect(OrderCycle.order_cycle.outgoing_exchanges).toEqual [ - {variants: {123: false, 234: true}} - {variants: {123: false, 333: true}} - ] - - describe 'loading an order cycle, reporting loadedness', -> - it 'reports its loadedness', -> - expect(OrderCycle.loaded).toBe(false) - OrderCycle.load('123') - $httpBackend.flush() - expect(OrderCycle.loaded).toBe(true) - - describe 'loading a new order cycle', -> - beforeEach -> - OrderCycle.new() - $httpBackend.flush() - - - it 'loads basic fields', -> - expect(OrderCycle.order_cycle.id).toEqual(123) - expect(OrderCycle.order_cycle.name).toEqual('New Order Cycle') - expect(OrderCycle.order_cycle.coordinator_id).toEqual(456) - - it 'initialises the incoming and outgoing exchanges', -> - expect(OrderCycle.order_cycle.incoming_exchanges).toEqual [] - expect(OrderCycle.order_cycle.outgoing_exchanges).toEqual [] - - it 'removes the original exchanges array', -> - expect(OrderCycle.order_cycle.exchanges).toBeUndefined() - - describe 'loading an existing order cycle', -> - beforeEach -> - OrderCycle.load('123') - $httpBackend.flush() - - it 'loads basic fields', -> - expect(OrderCycle.order_cycle.id).toEqual(123) - expect(OrderCycle.order_cycle.name).toEqual('Test Order Cycle') - expect(OrderCycle.order_cycle.coordinator_id).toEqual(456) - - it 'splits exchanges into incoming and outgoing', -> - expect(OrderCycle.order_cycle.incoming_exchanges).toEqual [ - sender_id: 1 - enterprise_id: 1 - incoming: true - active: true - ] - - expect(OrderCycle.order_cycle.outgoing_exchanges).toEqual [ - receiver_id: 2 - enterprise_id: 2 - incoming: false - active: true - ] - - it 'removes the original exchanges array', -> - expect(OrderCycle.order_cycle.exchanges).toBeUndefined() - - describe 'creating an order cycle', -> - beforeEach -> - spyOn(OrderCycle, 'confirmNoDistributors').and.returnValue true - - it 'redirects to the destination page on success', -> - OrderCycle.order_cycle = 'this is the order cycle' - spyOn(OrderCycle, 'dataForSubmit').and.returnValue('this is the submit data') - $httpBackend.expectPOST('/admin/order_cycles.json', { - order_cycle: 'this is the submit data' - }).respond {success: true} - - OrderCycle.create('/destination/page') - $httpBackend.flush() - expect($window.location).toEqual('/destination/page') - - it 'does not redirect on error', -> - OrderCycle.order_cycle = 'this is the order cycle' - spyOn(OrderCycle, 'dataForSubmit').and.returnValue('this is the submit data') - $httpBackend.expectPOST('/admin/order_cycles.json', { - order_cycle: 'this is the submit data' - }).respond 400, { errors: [] } - - OrderCycle.create('/destination/page') - $httpBackend.flush() - expect($window.location).toEqual(undefined) - - describe 'updating an order cycle', -> - beforeEach -> - spyOn(OrderCycle, 'confirmNoDistributors').and.returnValue true - - it 'redirects to the destination page on success', -> - form = jasmine.createSpyObj('order_cycle_form', ['$dirty', '$setPristine']) - OrderCycle.order_cycle = 'this is the order cycle' - spyOn(OrderCycle, 'dataForSubmit').and.returnValue('this is the submit data') - $httpBackend.expectPUT('/admin/order_cycles.json?reloading=1', { - order_cycle: 'this is the submit data' - }).respond {success: true} - - OrderCycle.update('/destination/page', form) - $httpBackend.flush() - expect($window.location).toEqual('/destination/page') - expect(form.$setPristine.calls.count()).toBe 1 - - it 'does not redirect on error', -> - OrderCycle.order_cycle = 'this is the order cycle' - spyOn(OrderCycle, 'dataForSubmit').and.returnValue('this is the submit data') - $httpBackend.expectPUT('/admin/order_cycles.json?reloading=1', { - order_cycle: 'this is the submit data' - }).respond 400, { errors: [] } - - OrderCycle.update('/destination/page') - $httpBackend.flush() - expect($window.location).toEqual(undefined) - - describe 'preparing data for form submission', -> - it 'calls all the methods', -> - OrderCycle.order_cycle = {foo: 'bar'} - spyOn(OrderCycle, 'removeInactiveExchanges') - spyOn(OrderCycle, 'translateCoordinatorFees') - spyOn(OrderCycle, 'translateExchangeFees') - OrderCycle.dataForSubmit() - expect(OrderCycle.removeInactiveExchanges).toHaveBeenCalled() - expect(OrderCycle.translateCoordinatorFees).toHaveBeenCalled() - expect(OrderCycle.translateExchangeFees).toHaveBeenCalled() - - it 'removes inactive exchanges', -> - data = - incoming_exchanges: [ - {enterprise_id: "1", active: false} - {enterprise_id: "2", active: true} - {enterprise_id: "3", active: false} - ] - outgoing_exchanges: [ - {enterprise_id: "4", active: true} - {enterprise_id: "5", active: false} - {enterprise_id: "6", active: true} - ] - - data = OrderCycle.removeInactiveExchanges(data) - - expect(data.incoming_exchanges).toEqual [ - {enterprise_id: "2", active: true} - ] - expect(data.outgoing_exchanges).toEqual [ - {enterprise_id: "4", active: true} - {enterprise_id: "6", active: true} - ] - - it 'converts coordinator fees into a list of ids', -> - order_cycle = - coordinator_fees: [ - {id: 1} - {id: 2} - ] - - data = OrderCycle.translateCoordinatorFees(order_cycle) - - expect(data.coordinator_fees).toBeUndefined() - expect(data.coordinator_fee_ids).toEqual [1, 2] - - it "preserves original data when converting coordinator fees", -> - OrderCycle.order_cycle = - coordinator_fees: [ - {id: 1} - {id: 2} - ] - - data = OrderCycle.deepCopy() - data = OrderCycle.translateCoordinatorFees(data) - - expect(OrderCycle.order_cycle.coordinator_fees).toEqual [{id: 1}, {id: 2}] - expect(OrderCycle.order_cycle.coordinator_fee_ids).toBeUndefined() - - describe "converting exchange fees into a list of ids", -> - order_cycle = null - data = null - - beforeEach -> - order_cycle = - incoming_exchanges: [ - enterprise_fees: [ - {id: 1} - {id: 2} - ] - ] - outgoing_exchanges: [ - enterprise_fees: [ - {id: 3} - {id: 4} - ] - ] - OrderCycle.order_cycle = order_cycle - - data = OrderCycle.deepCopy() - data = OrderCycle.translateExchangeFees(data) - - it 'converts exchange fees into a list of ids', -> - expect(data.incoming_exchanges[0].enterprise_fees).toBeUndefined() - expect(data.outgoing_exchanges[0].enterprise_fees).toBeUndefined() - expect(data.incoming_exchanges[0].enterprise_fee_ids).toEqual [1, 2] - expect(data.outgoing_exchanges[0].enterprise_fee_ids).toEqual [3, 4] - - it "preserves original data when converting exchange fees", -> - expect(order_cycle.incoming_exchanges[0].enterprise_fees).toEqual [{id: 1}, {id: 2}] - expect(order_cycle.outgoing_exchanges[0].enterprise_fees).toEqual [{id: 3}, {id: 4}] - expect(order_cycle.incoming_exchanges[0].enterprise_fee_ids).toBeUndefined() - expect(order_cycle.outgoing_exchanges[0].enterprise_fee_ids).toBeUndefined() - - describe "confirming when there are no distributors", -> - order_cycle_with_exchanges = order_cycle_without_exchanges = null - - beforeEach -> - order_cycle_with_exchanges = - outgoing_exchanges: [{}] - order_cycle_without_exchanges = - outgoing_exchanges: [] - - it "returns true when there are distributors", -> - spyOn(window, 'confirm') - OrderCycle.order_cycle = order_cycle_with_exchanges - expect(OrderCycle.confirmNoDistributors()).toBe true - expect(window.confirm).not.toHaveBeenCalled() - - it "returns true when there are no distributors but the user confirms", -> - spyOn(window, 'confirm').and.returnValue(true) - OrderCycle.order_cycle = order_cycle_without_exchanges - expect(OrderCycle.confirmNoDistributors()).toBe true - expect(window.confirm).toHaveBeenCalled() - - it "returns false when there are no distributors and the user does not confirm", -> - spyOn(window, 'confirm').and.returnValue(false) - OrderCycle.order_cycle = order_cycle_without_exchanges - expect(OrderCycle.confirmNoDistributors()).toBe false - expect(window.confirm).toHaveBeenCalled()