spree_backend 3.2.1 → 3.2.2

data/spec/features/admin/store_credits_spec.rb

@@ -1,93 +0,0 @@
-require 'spec_helper'
-
-describe 'Store credits admin' do
-  stub_authorization!
-
-  let!(:admin_user) { create(:admin_user) }
-  let!(:store_credit) { create(:store_credit) }
-
-  before do
-    allow(Spree.user_class).to receive(:find_by).and_return(store_credit.user)
-  end
-
-  describe 'visiting the store credits page' do
-    before do
-      visit spree.admin_path
-      click_link 'Users'
-    end
-
-    it 'should be on the store credits page' do
-      click_link store_credit.user.email
-      click_link 'Store Credits'
-      expect(page.current_path).to eq spree.admin_user_store_credits_path(store_credit.user)
-
-      store_credit_table = page.find('table')
-      expect(store_credit_table.all('tr').count).to eq 1
-      expect(store_credit_table).to have_content(Spree::Money.new(store_credit.amount).to_s)
-      expect(store_credit_table).to have_content(Spree::Money.new(store_credit.amount_used).to_s)
-      expect(store_credit_table).to have_content(store_credit.category_name)
-      expect(store_credit_table).to have_content(store_credit.created_by_email)
-    end
-  end
-
-  describe 'creating store credit' do
-    before do
-      visit spree.admin_path
-      click_link 'Users'
-      click_link store_credit.user.email
-      click_link 'Store Credits'
-      allow_any_instance_of(Spree::Admin::StoreCreditsController).to receive(:try_spree_current_user).and_return(admin_user)
-    end
-
-    it 'should create store credit and associate it with the user' do
-      click_link 'Add Store Credit'
-      page.fill_in 'store_credit_amount', with: '102.00'
-      select 'Exchange', from: 'store_credit_category_id'
-      click_button 'Create'
-
-      expect(page.current_path).to eq spree.admin_user_store_credits_path(store_credit.user)
-      store_credit_table = page.find('table')
-      expect(store_credit_table.all('tr').count).to eq 2
-      expect(Spree::StoreCredit.count).to eq 2
-    end
-  end
-
-  describe 'updating store credit' do
-    let(:updated_amount) { '99.0' }
-
-    before do
-      visit spree.admin_path
-      click_link 'Users'
-      click_link store_credit.user.email
-      click_link 'Store Credits'
-      allow_any_instance_of(Spree::Admin::StoreCreditsController).to receive(:try_spree_current_user).and_return(admin_user)
-    end
-
-    it 'should create store credit and associate it with the user' do
-      click_link 'Edit'
-      page.fill_in 'store_credit_amount', with: updated_amount
-      click_button 'Update'
-
-      expect(page.current_path).to eq spree.admin_user_store_credits_path(store_credit.user)
-      store_credit_table = page.find('table')
-      expect(store_credit_table).to have_content(Spree::Money.new(updated_amount).to_s)
-      expect(store_credit.reload.amount.to_f).to eq updated_amount.to_f
-    end
-  end
-
-  describe 'non-existent user' do
-    before do
-      visit spree.admin_path
-      click_link 'Users'
-      click_link store_credit.user.email
-      store_credit.user.destroy
-      allow(Spree.user_class).to receive(:find_by).and_return(nil)
-      click_link 'Store Credits'
-      allow_any_instance_of(Spree::Admin::StoreCreditsController).to receive(:try_spree_current_user).and_return(admin_user)
-    end
-
-    it 'should display flash withe error' do
-      expect(page).to have_content(Spree.t(:user_not_found))
-    end
-  end
-end

data/spec/features/admin/taxons_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-feature "Taxonomies and taxons" do
-  stub_authorization!
-
-  scenario "admin should be able to edit taxon" do
-    visit spree.new_admin_taxonomy_path
-
-    fill_in "Name", with: "Hello"
-    click_button "Create"
-
-    @taxonomy = Spree::Taxonomy.last
-
-    visit spree.edit_admin_taxonomy_taxon_path(@taxonomy, @taxonomy.root.id)
-
-    fill_in "taxon_name", with: "Shirt"
-    fill_in "taxon_description", with: "Discover our new rails shirts"
-
-    fill_in "permalink_part", with: "shirt-rails"
-    click_button "Update"
-    expect(page).to have_content("Taxon \"Shirt\" has been successfully updated!")
-  end
-
-  scenario "admin should be able to remove a product from a taxon", js: true do
-    taxon_1 = create(:taxon, name: 'Clothing')
-    product = create(:product)
-    product.taxons << taxon_1
-
-    visit spree.admin_taxons_path
-    select_clothing_from_select2
-
-    find('.product').hover
-    find('.product .dropdown-toggle').click
-    click_link "Delete From Taxon"
-    wait_for_ajax
-
-    visit current_path
-    select_clothing_from_select2
-
-    expect(page).to have_content("No results")
-  end
-
-  def select_clothing_from_select2
-    targetted_select2_search "Clothing", from: "#s2id_taxon_id"
-    wait_for_ajax
-  end
-end

data/spec/features/admin/users_spec.rb

@@ -1,286 +0,0 @@
-require 'spec_helper'
-
-describe 'Users', type: :feature do
-  include Spree::BaseHelper
-  stub_authorization!
-  include Spree::Admin::BaseHelper
-
-  let!(:country) { create(:country) }
-  let!(:user_a) { create(:user_with_addresses, email: 'a@example.com') }
-  let!(:user_b) { create(:user_with_addresses, email: 'b@example.com') }
-
-  let(:order) { create(:completed_order_with_totals, user: user_a, number: "R123") }
-
-  let(:order_2) do
-    create(:completed_order_with_totals, user: user_a, number: "R456").tap do |o|
-      li = o.line_items.last
-      li.update_column(:price, li.price + 10)
-    end
-  end
-
-  let(:orders) { [order, order_2] }
-
-  before do
-    stub_const('Spree::User', create(:user, email: 'example@example.com').class)
-  end
-
-  shared_examples_for 'a user page' do
-    it 'has lifetime stats' do
-      orders
-      visit current_url # need to refresh after creating the orders for specs that did not require orders
-      within("#user-lifetime-stats") do
-        [:total_sales, :num_orders, :average_order_value, :member_since].each do |stat_name|
-          expect(page).to have_content Spree.t(stat_name)
-        end
-        expect(page).to have_content (order.total + order_2.total)
-        expect(page).to have_content orders.count
-        expect(page).to have_content (orders.sum(&:total) / orders.count)
-        expect(page).to have_content pretty_time(user_a.created_at)
-      end
-    end
-
-    it 'can go back to the users list' do
-      expect(page).to have_link Spree.t(:users), href: spree.admin_users_path
-    end
-
-    it 'can navigate to the account page' do
-      expect(page).to have_link Spree.t(:"admin.user.account"), href: spree.edit_admin_user_path(user_a)
-    end
-
-    it 'can navigate to the order history' do
-      expect(page).to have_link Spree.t(:"admin.user.orders"), href: spree.orders_admin_user_path(user_a)
-    end
-
-    it 'can navigate to the items purchased' do
-      expect(page).to have_link Spree.t(:"admin.user.items"), href: spree.items_admin_user_path(user_a)
-    end
-  end
-
-  shared_examples_for 'a sortable attribute' do
-    before { click_link sort_link }
-
-    it "can sort asc" do
-      within_table(table_id) do
-        expect(page).to have_text text_match_1
-        expect(page).to have_text text_match_2
-        expect(text_match_1).to appear_before text_match_2
-      end
-    end
-
-    it "can sort desc" do
-      within_table(table_id) do
-        click_link sort_link
-
-        expect(page).to have_text text_match_1
-        expect(page).to have_text text_match_2
-        expect(text_match_2).to appear_before text_match_1
-      end
-    end
-  end
-
-  before do
-    visit spree.admin_path
-    click_link 'Users'
-  end
-
-  context 'users index' do
-
-    context "email" do
-      it_behaves_like "a sortable attribute" do
-        let(:text_match_1) { user_a.email }
-        let(:text_match_2) { user_b.email }
-        let(:table_id) { "listing_users" }
-        let(:sort_link) { "users_email_title" }
-      end
-    end
-
-    it 'displays the correct results for a user search' do
-      fill_in 'q_email_cont', with: user_a.email, visible: false
-      click_button 'Search', visible: false
-      within_table('listing_users') do
-        expect(page).to have_text user_a.email
-        expect(page).not_to have_text user_b.email
-      end
-    end
-  end
-
-  context 'editing users' do
-    before { click_link user_a.email }
-
-    it_behaves_like 'a user page'
-
-    it 'can edit the user email' do
-      fill_in 'user_email', with: 'a@example.com99'
-      click_button 'Update'
-
-      expect(user_a.reload.email).to eq 'a@example.com99'
-      expect(page).to have_text 'Account updated'
-      expect(find_field('user_email').value).to eq 'a@example.com99'
-    end
-
-    it 'can edit the user password' do
-      fill_in 'user_password', with: 'welcome'
-      fill_in 'user_password_confirmation', with: 'welcome'
-      click_button 'Update'
-
-      expect(page).to have_text 'Account updated'
-    end
-
-    it 'can edit user roles' do
-      Spree::Role.create name: "admin"
-      click_link 'Users'
-      click_link user_a.email
-
-      check 'user_spree_role_admin'
-      click_button 'Update'
-      expect(page).to have_text 'Account updated'
-      expect(find_field('user_spree_role_admin')['checked']).to be true
-    end
-
-    it 'can edit user shipping address' do
-      click_link "Addresses"
-
-      within("#admin_user_edit_addresses") do
-        fill_in "user_ship_address_attributes_address1", with: "1313 Mockingbird Ln"
-        click_button 'Update'
-        expect(find_field('user_ship_address_attributes_address1').value).to eq "1313 Mockingbird Ln"
-      end
-
-      expect(user_a.reload.ship_address.address1).to eq "1313 Mockingbird Ln"
-    end
-
-    it 'can edit user billing address' do
-      click_link "Addresses"
-
-      within("#admin_user_edit_addresses") do
-        fill_in "user_bill_address_attributes_address1", with: "1313 Mockingbird Ln"
-        click_button 'Update'
-        expect(find_field('user_bill_address_attributes_address1').value).to eq "1313 Mockingbird Ln"
-      end
-
-      expect(user_a.reload.bill_address.address1).to eq "1313 Mockingbird Ln"
-    end
-
-    context 'no api key exists' do
-      it 'can generate a new api key' do
-        within("#admin_user_edit_api_key") do
-          expect(user_a.spree_api_key).to be_blank
-          click_button Spree.t('generate_key', scope: 'api')
-        end
-
-        expect(user_a.reload.spree_api_key).to be_present
-
-        within("#admin_user_edit_api_key") do
-          expect(find("#current-api-key").text).to match /Key: #{user_a.spree_api_key}/
-        end
-      end
-    end
-
-    context 'an api key exists' do
-      before do
-        user_a.generate_spree_api_key!
-        expect(user_a.reload.spree_api_key).to be_present
-        visit current_path
-      end
-
-      it 'can clear an api key' do
-        within("#admin_user_edit_api_key") do
-          click_button Spree.t('clear_key', scope: 'api')
-        end
-
-        expect(user_a.reload.spree_api_key).to be_blank
-        expect { find("#current-api-key") }.to raise_error Capybara::ElementNotFound
-      end
-
-      it 'can regenerate an api key' do
-        old_key = user_a.spree_api_key
-
-        within("#admin_user_edit_api_key") do
-          click_button Spree.t('regenerate_key', scope: 'api')
-        end
-
-        expect(user_a.reload.spree_api_key).to be_present
-        expect(user_a.reload.spree_api_key).not_to eq old_key
-
-        within("#admin_user_edit_api_key") do
-          expect(find("#current-api-key").text).to match /Key: #{user_a.spree_api_key}/
-        end
-      end
-    end
-  end
-
-  context 'order history with sorting' do
-
-    before do
-      orders
-      click_link user_a.email
-      within("#sidebar") { click_link Spree.t(:"admin.user.orders") }
-    end
-
-    it_behaves_like 'a user page'
-
-    context "completed_at" do
-      it_behaves_like "a sortable attribute" do
-        let(:text_match_1) { order_time(order.completed_at) }
-        let(:text_match_2) { order_time(order_2.completed_at) }
-        let(:table_id) { "listing_orders" }
-        let(:sort_link) { "orders_completed_at_title" }
-      end
-    end
-
-    [:number, :state, :total].each do |attr|
-      context attr do
-        it_behaves_like "a sortable attribute" do
-          let(:text_match_1) { order.send(attr).to_s }
-          let(:text_match_2) { order_2.send(attr).to_s }
-          let(:table_id) { "listing_orders" }
-          let(:sort_link) { "orders_#{attr}_title" }
-        end
-      end
-    end
-  end
-
-  context 'items purchased with sorting' do
-
-    before do
-      orders
-      click_link user_a.email
-      within("#sidebar") { click_link Spree.t(:"admin.user.items") }
-    end
-
-    it_behaves_like 'a user page'
-
-    context "completed_at" do
-      it_behaves_like "a sortable attribute" do
-        let(:text_match_1) { order_time(order.completed_at) }
-        let(:text_match_2) { order_time(order_2.completed_at) }
-        let(:table_id) { "listing_items" }
-        let(:sort_link) { "orders_completed_at_title" }
-      end
-    end
-
-    [:number, :state].each do |attr|
-      context attr do
-        it_behaves_like "a sortable attribute" do
-          let(:text_match_1) { order.send(attr).to_s }
-          let(:text_match_2) { order_2.send(attr).to_s }
-          let(:table_id) { "listing_items" }
-          let(:sort_link) { "orders_#{attr}_title" }
-        end
-      end
-    end
-
-    it "has item attributes" do
-      items = order.line_items | order_2.line_items
-      expect(page).to have_table 'listing_items'
-      within_table('listing_items') do
-        items.each do |item|
-          expect(page).to have_selector(".item-name", text: item.product.name)
-          expect(page).to have_selector(".item-price", text: item.single_money.to_html)
-          expect(page).to have_selector(".item-quantity", text: item.quantity)
-          expect(page).to have_selector(".item-total", text: item.money.to_html)
-        end
-      end
-    end
-  end
-end

data/spec/helpers/admin/base_helper_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-describe Spree::Admin::BaseHelper, type: :helper do
-  include Spree::Admin::BaseHelper
-
-  context "#datepicker_field_value" do
-    it "should return nil when date is empty" do
-      date = nil
-      expect(datepicker_field_value(date)).to be_nil
-    end
-
-    it "should return a formatted date when date is present" do
-      date = "2013-08-14".to_time
-      expect(datepicker_field_value(date)).to eq("2013/08/14")
-    end
-  end
-
-  context "#plural_resource_name" do
-    it "should return correct form of class" do
-      resource_class = Spree::Product
-      expect(plural_resource_name(resource_class)).to eq("Products")
-    end
-  end
-
-  context "#order_time" do
-    it "prints in a format" do
-      expect(order_time(DateTime.new(2016, 5, 6, 13, 33))).to eq "2016-05-06 1:33 PM"
-    end
-  end
-end

data/spec/helpers/admin/navigation_helper_spec.rb

@@ -1,111 +0,0 @@
-# coding: UTF-8
-require 'spec_helper'
-
-describe Spree::Admin::NavigationHelper, type: :helper do
-  before(:each) do
-    # `spree` route helper is not accessible in `type: :helper` hence extending it explicitly
-    # https://github.com/rspec/rspec-rails/issues/1626
-    helper.extend Spree::TestingSupport::UrlHelpers
-  end
-
-  describe "#tab" do
-    before do
-      allow(helper).to receive(:cannot?).and_return false
-    end
-
-    context "creating an admin tab" do
-      it "should capitalize the first letter of each word in the tab's label" do
-        admin_tab = helper.tab(:orders)
-        expect(admin_tab).to include("Orders")
-      end
-    end
-
-    it "should accept options with label and capitalize each word of it" do
-      admin_tab = helper.tab(:orders, label: "delivered orders")
-      expect(admin_tab).to include("Delivered Orders")
-    end
-
-    it "should capitalize words with unicode characters" do
-      # overview
-      admin_tab = helper.tab(:orders, label: "přehled")
-      expect(admin_tab).to include("Přehled")
-    end
-
-    describe "selection" do
-      context "when match_path option is not supplied" do
-        subject(:tab) { helper.tab(:orders) }
-
-        it "should be selected if the controller matches" do
-          allow(controller).to receive(:controller_name).and_return("orders")
-          expect(subject).to include('selected')
-        end
-
-        it "should not be selected if the controller does not match" do
-          allow(controller).to receive(:controller_name).and_return("bonobos")
-          expect(subject).not_to include('selected')
-        end
-
-      end
-
-      context "when match_path option is supplied" do
-        before do
-          allow(helper).to receive(:request).and_return(double(ActionDispatch::Request, fullpath: "/admin/orders/edit/1"))
-        end
-
-        it "should be selected if the fullpath matches" do
-          allow(controller).to receive(:controller_name).and_return("bonobos")
-          tab = helper.tab(:orders, label: "delivered orders", match_path: '/orders')
-          expect(tab).to include('selected')
-        end
-
-        it "should be selected if the fullpath matches a regular expression" do
-          allow(controller).to receive(:controller_name).and_return("bonobos")
-          tab = helper.tab(:orders, label: "delivered orders", match_path: /orders$|orders\//)
-          expect(tab).to include('selected')
-        end
-
-        it "should not be selected if the fullpath does not match" do
-          allow(controller).to receive(:controller_name).and_return("bonobos")
-          tab = helper.tab(:orders, label: "delivered orders", match_path: '/shady')
-          expect(tab).not_to include('selected')
-        end
-
-        it "should not be selected if the fullpath does not match a regular expression" do
-          allow(controller).to receive(:controller_name).and_return("bonobos")
-          tab = helper.tab(:orders, label: "delivered orders", match_path: /shady$|shady\//)
-          expect(tab).not_to include('selected')
-        end
-      end
-    end
-  end
-
-  describe '#klass_for' do
-
-    it 'returns correct klass for Spree model' do
-      expect(klass_for(:products)).to eq(Spree::Product)
-      expect(klass_for(:product_properties)).to eq(Spree::ProductProperty)
-    end
-
-    it 'returns correct klass for non-spree model' do
-      class MyUser
-      end
-      expect(klass_for(:my_users)).to eq(MyUser)
-
-      Object.send(:remove_const, 'MyUser')
-    end
-
-    it 'returns correct namespaced klass for non-spree model' do
-      module My
-        class User
-        end
-      end
-
-      expect(klass_for(:my_users)).to eq(My::User)
-
-      My.send(:remove_const, 'User')
-      Object.send(:remove_const, 'My')
-    end
-
-  end
-
-end

data/spec/helpers/admin/promotion_rules_helper_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-module Spree
-  describe Spree::Admin::PromotionRulesHelper, type: :helper do
-    it "does not include existing rules in options" do
-      promotion = Spree::Promotion.new
-      promotion.promotion_rules << Spree::Promotion::Rules::ItemTotal.new
-
-      options = helper.options_for_promotion_rule_types(promotion)
-      expect(options).not_to match(/ItemTotal/)
-    end
-  end
-end

data/spec/helpers/admin/stock_movements_helper_spec.rb

@@ -1,30 +0,0 @@
-# coding: UTF-8
-require 'spec_helper'
-
-describe Spree::Admin::StockMovementsHelper, type: :helper do
-
-  describe "#pretty_originator" do
-
-    context "transfering between two locations" do
-      let(:destination_location) { create(:stock_location_with_items) }
-      let(:source_location) { create(:stock_location_with_items) }
-      let(:stock_item) { source_location.stock_items.order(:id).first }
-      let(:variant) { stock_item.variant }
-
-      before do
-        @stock_transfer = Spree::StockTransfer.create(reference: 'PO123')
-        variants = { variant => 5 }
-        @stock_transfer.transfer(source_location,
-                       destination_location,
-                       variants)
-        helper.pretty_originator(@stock_transfer.stock_movements.last)
-      end
-
-
-      it "returns link to stock transfer" do
-        expect(helper.pretty_originator(@stock_transfer.stock_movements.last)).to eq @stock_transfer.number
-      end
-    end
-  end
-
-end

data/spec/models/spree/resource_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  class Test
-  end
-  module Submodule
-    class Test
-    end
-  end
-end
-
-module Spree
-  module Admin
-    describe Resource, type: :model do
-      let(:resource_base) { Resource.new('spree/admin/test', 'test', 'widget') }
-      let(:resource_submodule) { Resource.new('spree/admin/submodule/test', 'test', 'widget') }
-      let(:resource_object_name) { Resource.new('spree/admin/test', 'test', 'gadget', 'widget') }
-
-      it "can get base model class" do
-        expect(resource_base.model_class).to eq(Spree::Test)
-      end
-
-      it "can get submodule class" do
-        expect(resource_submodule.model_class).to eq(Spree::Submodule::Test)
-      end
-
-      it "can get base model name (only used for parent)" do
-        expect(resource_base.model_name).to eq('widget')
-      end
-
-      it "can get submodule model name (only used for parent)" do
-        expect(resource_submodule.model_name).to eq('widget')
-      end
-
-      it "can get base object name" do
-        expect(resource_base.object_name).to eq('test')
-      end
-
-      it "can get submodule object name" do
-        expect(resource_submodule.object_name).to eq('submodule_test')
-      end
-
-      it "can get overridden object name" do
-        expect(resource_object_name.object_name).to eq('widget')
-      end
-    end
-  end
-end

data/spec/routing/admin_path_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  module Admin
-    RSpec.describe "AdminPath", type: :routing do
-      it "shoud route to admin by default" do
-        expect(spree.admin_path).to eq("/admin")
-      end
-
-      it "should route to the the configured path" do
-        Spree.admin_path = "/secret"
-        Rails.application.reload_routes!
-        expect(spree.admin_path).to eq("/secret")
-
-        # restore the path for other tests
-        Spree.admin_path = "/admin"
-        Rails.application.reload_routes!
-        expect(spree.admin_path).to eq("/admin")
-      end
-    end
-  end
-end