solidus_api 2.10.0 → 2.11.1

data/spec/requests/spree/api/stock_movements_controller_spec.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Spree
-  describe Api::StockMovementsController, type: :request do
-    let!(:stock_location) { create(:stock_location_with_items) }
-    let!(:stock_item) { stock_location.stock_items.order(:id).first }
-    let!(:stock_movement) { create(:stock_movement, stock_item: stock_item) }
-    let!(:attributes) { [:id, :quantity, :stock_item_id] }
-
-    before do
-      stub_authentication!
-    end
-
-    context 'as a user' do
-      it 'cannot see a list of stock movements' do
-        get spree.api_stock_location_stock_movements_path(stock_location)
-        expect(response.status).to eq(401)
-      end
-
-      it 'cannot see a stock movement' do
-        get spree.api_stock_location_stock_movement_path(stock_location, stock_movement)
-        expect(response.status).to eq(404)
-      end
-
-      it 'cannot create a stock movement' do
-        params = {
-          stock_movement: {
-            stock_item_id: stock_item.to_param
-          }
-        }
-
-        post spree.api_stock_location_stock_movements_path(stock_location), params: params
-        expect(response.status).to eq(401)
-      end
-    end
-
-    context 'as an admin' do
-      sign_in_as_admin!
-
-      it 'gets list of stock movements' do
-        get spree.api_stock_location_stock_movements_path(stock_location)
-        expect(json_response['stock_movements'].first).to have_attributes(attributes)
-        expect(json_response['stock_movements'].first['stock_item']['count_on_hand']).to eq 11
-      end
-
-      it 'can control the page size through a parameter' do
-        create(:stock_movement, stock_item: stock_item)
-        get spree.api_stock_location_stock_movements_path(stock_location), params: { per_page: 1 }
-        expect(json_response['count']).to eq(1)
-        expect(json_response['current_page']).to eq(1)
-        expect(json_response['pages']).to eq(2)
-      end
-
-      it 'can query the results through a paramter' do
-        create(:stock_movement, :received, quantity: 10, stock_item: stock_item)
-        get spree.api_stock_location_stock_movements_path(stock_location), params: { q: { quantity_eq: '10' } }
-        expect(json_response['count']).to eq(1)
-      end
-
-      it 'gets a stock movement' do
-        get spree.api_stock_location_stock_movement_path(stock_location, stock_movement)
-        expect(json_response).to have_attributes(attributes)
-        expect(json_response['stock_item_id']).to eq stock_movement.stock_item_id
-      end
-
-      it 'can create a new stock movement' do
-        params = {
-          stock_movement: {
-            stock_item_id: stock_item.to_param
-          }
-        }
-
-        post spree.api_stock_location_stock_movements_path(stock_location), params: params
-        expect(response.status).to eq(201)
-        expect(json_response).to have_attributes(attributes)
-      end
-    end
-  end
-end

data/spec/requests/spree/api/store_credit_events_controller_spec.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Spree::Api::StoreCreditEventsController, type: :request do
-  let(:api_user) { create(:user, :with_api_key) }
-
-  describe "GET mine" do
-    subject do
-      get spree.mine_api_store_credit_events_path(format: :json), headers: { Authorization: "Bearer #{api_key}" }
-    end
-
-    context "no current api user" do
-      let(:api_key) { nil }
-
-      before { subject }
-
-      it "returns a 401" do
-        expect(response.status).to eq 401
-      end
-    end
-
-    context "the current api user is authenticated" do
-      let(:current_api_user) { create(:user, :with_api_key) }
-      let(:api_key) { current_api_user.spree_api_key }
-
-      context "the user doesn't have store credit" do
-        before { subject }
-
-        it "should set the events variable to empty list" do
-          expect(json_response["store_credit_events"]).to eq []
-        end
-
-        it "returns a 200" do
-          expect(response.status).to eq 200
-        end
-      end
-
-      context "the user has store credit" do
-        let!(:store_credit) { create(:store_credit, user: current_api_user) }
-
-        before { subject }
-
-        it "should contain the store credit allocation event" do
-          expect(json_response["store_credit_events"].size).to eq 1
-          expect(json_response["store_credit_events"][0]).to include(
-            "display_amount" => "$150.00",
-            "display_user_total_amount" => "$150.00",
-            "display_action" => "Added"
-          )
-        end
-
-        it "returns a 200" do
-          expect(response.status).to eq 200
-        end
-      end
-    end
-  end
-end

data/spec/requests/spree/api/stores_controller_spec.rb

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-module Spree
-  describe Api::StoresController, type: :request do
-    let!(:store) do
-      create(:store, name: "My Spree Store", url: "spreestore.example.com")
-    end
-
-    before do
-      stub_authentication!
-    end
-
-    context "as an admin" do
-      sign_in_as_admin!
-
-      let!(:non_default_store) do
-        create(:store,
-          name: "Extra Store",
-          url: "spreestore-5.example.com",
-          default: false)
-      end
-
-      it "can list the available stores" do
-        get spree.api_stores_path
-        expect(json_response["stores"]).to match_array([
-          {
-            "id" => store.id,
-            "name" => "My Spree Store",
-            "url" => "spreestore.example.com",
-            "meta_description" => nil,
-            "meta_keywords" => nil,
-            "seo_title" => nil,
-            "mail_from_address" => "spree@example.org",
-            "default_currency" => nil,
-            "code" => store.code,
-            "default" => true,
-            "available_locales" => ["en"]
-          },
-          {
-            "id" => non_default_store.id,
-            "name" => "Extra Store",
-            "url" => "spreestore-5.example.com",
-            "meta_description" => nil,
-            "meta_keywords" => nil,
-            "seo_title" => nil,
-            "mail_from_address" => "spree@example.org",
-            "default_currency" => nil,
-            "code" => non_default_store.code,
-            "default" => false,
-            "available_locales" => ["en"]
-          }
-        ])
-      end
-
-      it "can get the store details" do
-        get spree.api_store_path(store)
-        expect(json_response).to eq(
-          "id" => store.id,
-          "name" => "My Spree Store",
-          "url" => "spreestore.example.com",
-          "meta_description" => nil,
-          "meta_keywords" => nil,
-          "seo_title" => nil,
-          "mail_from_address" => "spree@example.org",
-          "default_currency" => nil,
-          "code" => store.code,
-          "default" => true,
-          "available_locales" => ["en"]
-        )
-      end
-
-      it "can create a new store" do
-        store_hash = {
-          code: "spree123",
-          name: "Hack0rz",
-          url: "spree123.example.com",
-          mail_from_address: "me@example.com"
-        }
-        post spree.api_stores_path, params: { store: store_hash }
-        expect(response.status).to eq(201)
-      end
-
-      it "can update an existing store" do
-        store_hash = {
-          url: "spree123.example.com",
-          mail_from_address: "me@example.com"
-        }
-        put spree.api_store_path(store), params: { store: store_hash }
-        expect(response.status).to eq(200)
-        expect(store.reload.url).to eql "spree123.example.com"
-        expect(store.reload.mail_from_address).to eql "me@example.com"
-      end
-
-      context "deleting a store" do
-        it "will fail if it's the default Store" do
-          delete spree.api_store_path(store)
-          expect(response.status).to eq(422)
-          expect(json_response["errors"]["base"]).to eql(
-            ["Cannot destroy the default Store."]
-          )
-        end
-
-        it "will destroy the store" do
-          delete spree.api_store_path(non_default_store)
-          expect(response.status).to eq(204)
-        end
-      end
-    end
-
-    context "as an user" do
-      it "cannot list all the stores" do
-        get spree.api_stores_path
-        expect(response.status).to eq(401)
-      end
-
-      it "cannot get the store details" do
-        get spree.api_store_path(store)
-        expect(response.status).to eq(401)
-      end
-
-      it "cannot create a new store" do
-        post spree.api_stores_path, params: { store: {} }
-        expect(response.status).to eq(401)
-      end
-
-      it "cannot update an existing store" do
-        put spree.api_store_path(store), params: { store: {} }
-        expect(response.status).to eq(401)
-      end
-    end
-  end
-end

data/spec/requests/spree/api/taxonomies_controller_spec.rb

@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Spree
-  describe Api::TaxonomiesController, type: :request do
-    let(:taxonomy) { create(:taxonomy) }
-    let(:taxon) { create(:taxon, name: "Ruby", taxonomy: taxonomy) }
-    let(:taxon2) { create(:taxon, name: "Rails", taxonomy: taxonomy) }
-    let(:attributes) { [:id, :name] }
-
-    before do
-      stub_authentication!
-      taxon2.children << create(:taxon, name: "3.2.2", taxonomy: taxonomy)
-      taxon.children << taxon2
-      taxonomy.root.children << taxon
-    end
-
-    context "as a normal user" do
-      it "gets all taxonomies" do
-        get spree.api_taxonomies_path
-
-        expect(json_response["taxonomies"].first['name']).to eq taxonomy.name
-        expect(json_response["taxonomies"].first['root']['taxons'].count).to eq 1
-      end
-
-      it 'can control the page size through a parameter' do
-        create(:taxonomy)
-        get spree.api_taxonomies_path, params: { per_page: 1 }
-        expect(json_response['count']).to eq(1)
-        expect(json_response['current_page']).to eq(1)
-        expect(json_response['pages']).to eq(2)
-      end
-
-      it 'can query the results through a paramter' do
-        expected_result = create(:taxonomy, name: 'Style')
-        get spree.api_taxonomies_path, params: { q: { name_cont: 'style' } }
-        expect(json_response['count']).to eq(1)
-        expect(json_response['taxonomies'].first['name']).to eq expected_result.name
-      end
-
-      it "gets a single taxonomy" do
-        get spree.api_taxonomy_path(taxonomy.id)
-
-        expect(json_response['name']).to eq taxonomy.name
-
-        children = json_response['root']['taxons']
-        expect(children.count).to eq 1
-        expect(children.first['name']).to eq taxon.name
-        expect(children.first.key?('taxons')).to be false
-      end
-
-      it "gets a single taxonomy with set=nested" do
-        get spree.api_taxonomy_path(taxonomy.id), params: { set: 'nested' }
-
-        expect(json_response['name']).to eq taxonomy.name
-
-        children = json_response['root']['taxons']
-        expect(children.first.key?('taxons')).to be true
-      end
-
-      it "gets the jstree-friendly version of a taxonomy" do
-        expect(Spree::Deprecation).to(receive(:warn))
-        get spree.jstree_api_taxonomy_path(taxonomy.id)
-        expect(json_response["data"]).to eq(taxonomy.root.name)
-        expect(json_response["attr"]).to eq({ "id" => taxonomy.root.id, "name" => taxonomy.root.name })
-        expect(json_response["state"]).to eq("closed")
-      end
-
-      it "can learn how to create a new taxonomy" do
-        get spree.new_api_taxonomy_path(taxonomy.id)
-        expect(json_response["attributes"]).to eq(attributes.map(&:to_s))
-        required_attributes = json_response["required_attributes"]
-        expect(required_attributes).to include("name")
-      end
-
-      it "cannot create a new taxonomy if not an admin" do
-        post spree.api_taxonomies_path, params: { taxonomy: { name: "Location" } }
-        assert_unauthorized!
-      end
-
-      it "cannot update a taxonomy" do
-        put spree.api_taxonomy_path(taxonomy.id), params: { taxonomy: { name: "I hacked your store!" } }
-        assert_unauthorized!
-      end
-
-      it "cannot delete a taxonomy" do
-        delete spree.api_taxonomy_path(taxonomy.id)
-        assert_unauthorized!
-      end
-    end
-
-    context "as an admin" do
-      sign_in_as_admin!
-
-      it "can create" do
-        post spree.api_taxonomies_path, params: { taxonomy: { name: "Colors" } }
-        expect(json_response).to have_attributes(attributes)
-        expect(response.status).to eq(201)
-      end
-
-      it "cannot create a new taxonomy with invalid attributes" do
-        post spree.api_taxonomies_path, params: { taxonomy: {} }
-        expect(response.status).to eq(422)
-        expect(json_response["error"]).to eq("Invalid resource. Please fix errors and try again.")
-      end
-
-      it "can destroy" do
-        delete spree.api_taxonomy_path(taxonomy.id)
-        expect(response.status).to eq(204)
-      end
-    end
-  end
-end

data/spec/requests/spree/api/taxons_controller_spec.rb

@@ -1,217 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Spree
-  describe Api::TaxonsController, type: :request do
-    let!(:taxonomy) { create(:taxonomy) }
-    let!(:taxon) { create(:taxon, name: "Ruby", parent: taxonomy.root, taxonomy: taxonomy) }
-    let!(:taxon2) { create(:taxon, name: "Rails", parent: taxon, taxonomy: taxonomy) }
-    let!(:rails_v3_2_2) { create(:taxon, name: "3.2.2", parent: taxon2, taxonomy: taxonomy) }
-    let(:attributes) { ["id", "name", "pretty_name", "permalink", "parent_id", "taxonomy_id"] }
-
-    before do
-      stub_authentication!
-    end
-
-    context "as a normal user" do
-      it "gets all taxons for a taxonomy" do
-        get spree.api_taxonomy_taxons_path(taxonomy)
-
-        expect(json_response['taxons'].first['name']).to eq taxon.name
-        children = json_response['taxons'].first['taxons']
-        expect(children.count).to eq 1
-        expect(children.first['name']).to eq taxon2.name
-        expect(children.first['taxons'].count).to eq 1
-      end
-
-      # Regression test for https://github.com/spree/spree/issues/4112
-      it "does not include children when asked not to" do
-        get spree.api_taxonomy_taxons_path(taxonomy), params: { without_children: 1 }
-
-        expect(json_response['taxons'].first['name']).to eq(taxon.name)
-        expect(json_response['taxons'].first['taxons']).to be_nil
-      end
-
-      it "paginates through taxons" do
-        new_taxon = create(:taxon, name: "Go", taxonomy: taxonomy)
-        taxonomy.root.children << new_taxon
-        expect(taxonomy.root.children.count).to eql(2)
-        get spree.api_taxonomy_taxons_path(taxonomy), params: { page: 1, per_page: 1 }
-        expect(json_response["count"]).to eql(1)
-        expect(json_response["total_count"]).to eql(2)
-        expect(json_response["current_page"]).to eql(1)
-        expect(json_response["per_page"]).to eql(1)
-        expect(json_response["pages"]).to eql(2)
-      end
-
-      describe 'searching' do
-        context 'with a name' do
-          before do
-            get spree.api_taxons_path, params: { q: { name_cont: name } }
-          end
-
-          context 'with one result' do
-            let(:name) { "Ruby" }
-
-            it "returns an array including the matching taxon" do
-              expect(json_response['taxons'].count).to eq(1)
-              expect(json_response['taxons'].first['name']).to eq "Ruby"
-            end
-          end
-
-          context 'with no results' do
-            let(:name) { "Imaginary" }
-
-            it 'returns an empty array of taxons' do
-              expect(json_response.keys).to include('taxons')
-              expect(json_response['taxons'].count).to eq(0)
-            end
-          end
-        end
-
-        context 'with no filters' do
-          it "gets all taxons" do
-            get spree.api_taxons_path
-
-            expect(json_response['taxons'].first['name']).to eq taxonomy.root.name
-            children = json_response['taxons'].first['taxons']
-            expect(children.count).to eq 1
-            expect(children.first['name']).to eq taxon.name
-            expect(children.first['taxons'].count).to eq 1
-          end
-        end
-      end
-
-      context 'filtering by taxon ids' do
-        it 'returns only requested id' do
-          get spree.api_taxons_path, params: { ids: [rails_v3_2_2.id] }
-
-          expect(json_response['taxons'].size).to eq 1
-        end
-
-        it 'returns only requested ids' do
-          # We need a completly new branch to avoid having parent that can be preloaded from the rails ancestors
-          python   = create(:taxon, name: "Python", parent: taxonomy.root, taxonomy: taxonomy)
-          python_three = create(:taxon, name: "3.0", parent: python, taxonomy: taxonomy)
-
-          get spree.api_taxons_path, params: { ids: [rails_v3_2_2.id, python_three.id] }
-
-          expect(json_response['taxons'].size).to eq 2
-        end
-      end
-
-      it "gets a single taxon" do
-        get spree.api_taxonomy_taxon_path(taxonomy, taxon.id)
-
-        expect(json_response['name']).to eq taxon.name
-        expect(json_response['taxons'].count).to eq 1
-      end
-
-      it "gets all taxons in JSTree form" do
-        expect(Spree::Deprecation).to(receive(:warn))
-        get spree.jstree_api_taxonomy_taxon_path(taxonomy, taxon.id)
-        response = json_response.first
-        expect(response["data"]).to eq(taxon2.name)
-        expect(response["attr"]).to eq({ "name" => taxon2.name, "id" => taxon2.id })
-        expect(response["state"]).to eq("closed")
-      end
-
-      it "can learn how to create a new taxon" do
-        get spree.new_api_taxonomy_taxon_path(taxonomy)
-        expect(json_response["attributes"]).to eq(attributes.map(&:to_s))
-        required_attributes = json_response["required_attributes"]
-        expect(required_attributes).to include("name")
-      end
-
-      it "cannot create a new taxon if not an admin" do
-        post spree.api_taxonomy_taxons_path(taxonomy), params: { taxon: { name: "Location" } }
-        assert_unauthorized!
-      end
-
-      it "cannot update a taxon" do
-        put spree.api_taxonomy_taxon_path(taxonomy, taxon.id), params: { taxon: { name: "I hacked your store!" } }
-        assert_unauthorized!
-      end
-
-      it "cannot delete a taxon" do
-        delete spree.api_taxonomy_taxon_path(taxonomy, taxon.id)
-        assert_unauthorized!
-      end
-
-      context "with caching enabled" do
-        let!(:product) { create(:product, taxons: [taxon]) }
-
-        before do
-          ActionController::Base.perform_caching = true
-        end
-
-        it "handles exclude_data correctly" do
-          get spree.api_taxon_products_path, params: { id: taxon.id, simple: true }
-          expect(response).to be_successful
-          simple_response = json_response
-
-          get spree.api_taxon_products_path, params: { id: taxon.id }
-          expect(response).to be_successful
-          full_response = json_response
-
-          expect(simple_response["products"][0]["description"]).to be_nil
-          expect(full_response["products"][0]["description"]).not_to be_nil
-        end
-
-        after do
-          ActionController::Base.perform_caching = false
-        end
-      end
-    end
-
-    context "as an admin" do
-      sign_in_as_admin!
-
-      it "can create" do
-        post spree.api_taxonomy_taxons_path(taxonomy), params: { taxon: { name: "Colors" } }
-        expect(json_response).to have_attributes(attributes)
-        expect(response.status).to eq(201)
-
-        expect(taxonomy.reload.root.children.count).to eq 2
-        taxon = Spree::Taxon.where(name: 'Colors').first
-
-        expect(taxon.parent_id).to eq taxonomy.root.id
-        expect(taxon.taxonomy_id).to eq taxonomy.id
-      end
-
-      it "can update the position in the list" do
-        taxonomy.root.children << taxon2
-        put spree.api_taxonomy_taxon_path(taxonomy, taxon.id), params: { taxon: { parent_id: taxon.parent_id, child_index: 2 } }
-        expect(response.status).to eq(200)
-        expect(taxonomy.reload.root.children[0]).to eql taxon2
-        expect(taxonomy.reload.root.children[1]).to eql taxon
-      end
-
-      it "cannot create a new taxon with invalid attributes" do
-        post spree.api_taxonomy_taxons_path(taxonomy), params: { taxon: { foo: :bar } }
-        expect(response.status).to eq(422)
-        expect(json_response["error"]).to eq("Invalid resource. Please fix errors and try again.")
-
-        expect(taxonomy.reload.root.children.count).to eq 1
-      end
-
-      it "cannot create a new taxon with invalid taxonomy_id" do
-        post spree.api_taxonomy_taxons_path(1000), params: { taxon: { name: "Colors" } }
-        expect(response.status).to eq(422)
-        expect(json_response["error"]).to eq("Invalid resource. Please fix errors and try again.")
-
-        errors = json_response["errors"]
-        expect(errors["taxonomy_id"]).not_to be_nil
-        expect(errors["taxonomy_id"].first).to eq "Invalid taxonomy id."
-
-        expect(taxonomy.reload.root.children.count).to eq 1
-      end
-
-      it "can destroy" do
-        delete spree.api_taxonomy_taxon_path(taxonomy, taxon.id)
-        expect(response.status).to eq(204)
-      end
-    end
-  end
-end