 			@ssr = new vtex.portalPlugins.SkuSelectorRenderer({}, {}, {})
 
 		it 'should exist', ->
+			#Assert
 			expect(vtex.portalPlugins.SkuSelectorRenderer).toBeDefined()
+
 		it 'should be instantiated', ->
+			#Assert
 			expect(@ssr instanceof vtex.portalPlugins.SkuSelectorRenderer).toBe(true)
 
 		it 'should call updatePriceAvailable', ->
+			#Arrange
 			sku = {available: true}
 			spyOn(@ssr, 'updatePriceAvailable')
+
+			#Act
 			@ssr.updatePrice(sku)
 
+			#Assert
 			expect(@ssr.updatePriceAvailable).toHaveBeenCalledWith(sku)
 
+
 		it 'should call updatePriceUnavailable', ->
+			#Arrange
 			sku = {available: false}
 			spyOn(@ssr, 'updatePriceUnavailable')
+
+			#Act
 			@ssr.updatePrice(sku)
 
+			#Assert
 			expect(@ssr.updatePriceUnavailable).toHaveBeenCalled()
 
 

			@ss = new vtex.portalPlugins.SkuSelector(@mock)

		it 'should exist', ->
			expect(vtex.portalPlugins.SkuSelector).toBeDefined()
		it 'should be instantiated', ->
			expect(@ss instanceof vtex.portalPlugins.SkuSelector).toBe(true)

		it 'should import productId', ->
			expect(@ss.productId).toEqual(@mock.productId)
		it 'should import name', ->
			expect(@ss.name).toEqual(@mock.name)
		it 'should import dimensions', ->
			# Number of dimensions
			expect(@ss.dimensions.length).toEqual(@mock.dimensions.length)
			# Dimension names
			expect((dim.name for dim in @ss.dimensions)).toEqual(@mock.dimensions)
			# Dimension selected map
			expect(dim.selected).toBeUndefined() for dim in @ss.dimensions
			# Dimension values
			expect(dim.values).toEqual(@mock.dimensionsMap[dim.name]) for dim in @ss.dimensions
		it 'should import skus', ->
			expect(@ss.skus).toEqual(@mock.skus)

		it 'should find undefined dimensions', ->
			undefinedDimensions = (dim for dim in @ss.dimensions when dim.selected is undefined)
			expect(@ss.findUndefinedDimensions()).toEqual(undefinedDimensions)

		it 'should find available skus', ->
			availableSkus = (sku for sku in @ss.skus when sku.available is true)
			expect(@ss.findAvailableSkus()).toEqual(availableSkus)

		#TODO it 'should assert that a sku is selectable', ->

		#TODO it 'should find the selectable skus', ->


		it 'should search the dimensions using the given function', ->
			fn = ()->true
			spyOn($, 'grep').andCallThrough()
			expect(@ss.searchDimensions(fn)).toEqual(@ss.dimensions)
			expect($.grep).toHaveBeenCalledWith(@ss.dimensions, fn)

		#TODO it 'should search the dimensions correctly', ->

		it 'should get the dimension by its name', ->
			expect(@ss.getDimensionByName(@ss.dimensions[0].name)).toEqual(@ss.dimensions[0])

		describe 'findSelectedSku', ->
			it 'should find when it is unique', ->
				spyOn(@ss, 'findSelectableSkus').andReturn([@mock.skus[0]])
				expect(@ss.findSelectedSku()).toEqual(@mock.skus[0])

			it 'should not find when it is not unique', ->
				spyOn(@ss, 'findSelectableSkus').andReturn([@mock.skus[0], @mock.skus[1]])
				expect(@ss.findSelectedSku()).toBeUndefined()

			it 'should not find when it is empty', ->
				spyOn(@ss, 'findSelectableSkus').andReturn([])
				expect(@ss.findSelectedSku()).toBeUndefined()


		it 'should get and set selected dimension', ->
			dim  = @ss.dimensions[0]
			@ss.setSelectedDimension(dim.name, "12kg")
			expect(@ss.getSelectedDimension(dim.name)).toEqual("12kg")

		it 'should reset the next dimensions', ->
			@ss.resetNextDimensions(@ss.dimensions[0].name)
			expect(@ss.getSelectedDimension(dim.name)).toBeUndefined() for dim, i in @ss.dimensions when i > 0



		@mocks = (getJSONFixture(name) for name in mockNames)

	it 'should have loaded JSON fixtures correctly', ->
		#Assert
		expect(typeof @mocks).toBe(typeof [])
		expect(@mocks[0]).toBeDefined()
		expect(typeof @mocks[0]).toBe(typeof {})

