solidus_graphql_api 0.1.0

data/spec/integration/queries/product_by_slug_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe_query :product_by_slug, query: :product_by_slug, freeze_date: true do
+  let!(:product) { create(:product, id: 1, name: 'Product', slug: 'slug', sku: 'SKU') }
+
+  let!(:option_type) { create(:option_type, id: 1, name: 'foo-size') }
+  let!(:option_value) { create(:option_value, id: 1, name: 'Size', option_type: option_type) }
+  let!(:product_option_type) { create(:product_option_type, id: 1, product: product, option_type: option_type) }
+
+  let!(:product_property) { create(:product_property, id: 1, product: product) }
+
+  let!(:first_variant) { create(:base_variant, product: product) }
+  let!(:second_variant) { create(:base_variant, product: product) }
+
+  before do
+    product.master.update!(option_values: [option_value])
+  end
+
+  field :productBySlug do
+    context "when the slug doesn't exist" do
+      let(:query_variables) { { slug: 'non-existent-slug' } }
+
+      it { expect(subject.dig(:data, :productBySlug)).to be_nil }
+    end
+
+    context 'when the slug exists' do
+      let(:query_variables) { { slug: 'slug' } }
+
+      let(:args) do
+        {
+          product: product,
+          first_variant: first_variant,
+          second_variant: second_variant
+        }
+      end
+
+      it { is_expected.to match_response(:product_by_slug).with_args(args) }
+    end
+  end
+end

data/spec/integration/queries/products_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe_query :products, query: :products, freeze_date: true do
+  connection_field :products do
+    subject { query_response.dig(:data, :products, :nodes) }
+
+    let(:current_user) { create :user }
+    let(:current_pricing_options) { Spree::Config.pricing_options_class.new }
+    let(:query_context) do
+      { current_user: current_user,
+        current_pricing_options: current_pricing_options }
+    end
+
+    context 'when products do not exist' do
+      it { is_expected.to eq [] }
+    end
+
+    context 'when products exist' do
+      let!(:solidus_t_shirt) { create(:product, name: 'Solidus T-Shirt', id: 1, price: 19.99) }
+      let!(:ruby_mug) { create(:product, name: 'Ruby Mug', id: 2, price: 9.99) }
+      let!(:solidus_mug) { create(:product, name: 'Solidus Mug ', id: 3, price: 9.99) }
+      let!(:solidus_tote) { create(:product, name: 'Solidus Tote', id: 4, price: 15.99) }
+
+      context 'when no query is passed' do
+        it { is_expected.to match_array([{ id: solidus_t_shirt.id }, { id: ruby_mug.id }, { id: solidus_mug.id }, { id: solidus_tote.id }]) }
+      end
+
+      context 'when a query is passed' do
+        let(:taxon) { create(:taxon, products: [solidus_tote]) }
+        let(:search) { { price_range_any: ["Under $10.00", "$15.00 - $18.00"] } }
+        let(:taxon_id) { SolidusGraphqlApi::Schema.id_from_object(taxon, nil, nil) }
+        let(:query_variables) { { query: { taxon: taxon_id, keywords: "Solidus", search: search } } }
+
+        it { is_expected.to match_array([{ id: solidus_tote.id }]) }
+      end
+    end
+  end
+end

data/spec/integration/queries/taxonomies_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe_query :taxonomies do
+  connection_field :taxonomies, query: :taxonomies, freeze_date: true do
+    context 'when taxonomies does not exists' do
+      it { expect(subject.dig(:data, :taxonomies, :nodes)).to eq [] }
+    end
+
+    context 'when taxonomies exists' do
+      let!(:brand_taxonomy) { create(:taxonomy, :with_taxon_meta, id: 1, root_taxon_id: 1) }
+      let!(:category_taxonomy) { create(:taxonomy, id: 2, name: 'Category', root_taxon_id: 2) }
+
+      before do
+        create(:taxon, id: 3, name: 'Solidus', parent: brand_taxonomy.root, taxonomy: brand_taxonomy)
+      end
+
+      it { is_expected.to match_response(:taxonomies) }
+    end
+  end
+end

data/spec/lib/solidus_graphql_api/batch_loader/belongs_to_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::BatchLoader::BelongsTo do
+  subject(:loader) do
+    described_class.new(
+      object,
+      object.class.reflect_on_association(association),
+      options
+    )
+  end
+
+  let(:options) { {} }
+
+  context 'with a regular association' do
+    with_model :Article, scope: :all do
+      model do
+        has_many :comments
+      end
+    end
+
+    with_model :Comment, scope: :all do
+      table do |t|
+        t.belongs_to :article
+      end
+
+      model do
+        belongs_to :article
+      end
+    end
+
+    let!(:object) { Comment.create!(article: Article.create!) }
+    let(:association) { :article }
+
+    it 'loads the association properly' do
+      expect(loader.load.sync).to eq(object.article)
+    end
+  end
+
+  context 'with a polymorphic association' do
+    with_model :Image, scope: :all do
+      table do |t|
+        t.integer :imageable_id
+        t.string :imageable_type
+      end
+
+      model do
+        belongs_to :imageable, polymorphic: true
+      end
+    end
+
+    with_model :Article, scope: :all do
+      model do
+        has_many :images, as: :imageable
+      end
+    end
+
+    let!(:object) { Image.create!(imageable: Article.create!) }
+    let(:association) { :imageable }
+    let(:options) { { klass: Article } }
+
+    it 'loads the association properly' do
+      expect(loader.load.sync).to eq(object.imageable)
+    end
+  end
+end

data/spec/lib/solidus_graphql_api/batch_loader/has_many_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::BatchLoader::HasMany do
+  subject(:loader) do
+    described_class.new(
+      article,
+      Article.reflect_on_association(:comments)
+    )
+  end
+
+  with_model :Article, scope: :all do
+    model do
+      has_many :comments
+    end
+  end
+
+  with_model :Comment, scope: :all do
+    table do |t|
+      t.belongs_to :article
+    end
+
+    model do
+      belongs_to :article
+    end
+  end
+
+  let!(:article) { Article.create! }
+
+  before do
+    article.comments.create!
+  end
+
+  it 'loads the association properly' do
+    expect(loader.load.sync).to eq(article.comments)
+  end
+end

data/spec/lib/solidus_graphql_api/batch_loader/has_many_through_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::BatchLoader::HasManyThrough do
+  subject(:loader) do
+    described_class.new(
+      article,
+      Article.reflect_on_association(:comment_authors)
+    )
+  end
+
+  with_model :Article, scope: :all do
+    model do
+      has_many :comments
+      has_many :comment_authors, through: :comments, source: :author
+    end
+  end
+
+  with_model :Comment, scope: :all do
+    table do |t|
+      t.belongs_to :article
+      t.belongs_to :author
+    end
+
+    model do
+      belongs_to :article
+      belongs_to :author
+    end
+  end
+
+  with_model :Author, scope: :all do
+    model do
+      has_many :comments
+    end
+  end
+
+  let!(:article) { Article.create! }
+
+  before do
+    article.comments.create!(author: Author.create!)
+  end
+
+  it 'loads the association properly' do
+    expect(loader.load.sync).to eq(article.comment_authors)
+  end
+end

data/spec/lib/solidus_graphql_api/batch_loader/has_one_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::BatchLoader::HasOne do
+  subject(:loader) do
+    described_class.new(
+      article,
+      Article.reflect_on_association(:image)
+    )
+  end
+
+  with_model :Article, scope: :all do
+    model do
+      has_one :image
+    end
+  end
+
+  with_model :Image, scope: :all do
+    table do |t|
+      t.belongs_to :article
+    end
+
+    model do
+      belongs_to :article
+    end
+  end
+
+  let!(:article) { Article.create! }
+
+  before do
+    article.create_image!
+  end
+
+  it 'loads the association properly' do
+    expect(loader.load.sync).to eq(article.image)
+  end
+end

data/spec/lib/solidus_graphql_api/context_spec.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Context do
+  let(:schema_context) { described_class.new(request: request) }
+
+  let(:headers) do
+    headers_hash = {}
+    headers_hash['Authorization'] = "Bearer #{authorization_token}" if defined?(authorization_token) && authorization_token
+    headers_hash['X-Spree-Order-Token'] = order_token if defined?(order_token) && order_token
+    headers_hash
+  end
+
+  let(:request) { ActionDispatch::TestRequest.create.tap { |request| request.headers.merge!(headers) } }
+
+  describe '#to_h' do
+    subject { schema_context.to_h }
+
+    let(:current_user) { Spree::User.new }
+    let(:current_ability) { Spree::Ability.new(nil) }
+    let!(:default_store) { create(:store, default: true) }
+    let(:current_order) { build(:order) }
+    let(:current_pricing_options) { Spree::Config.pricing_options_class.new }
+    let(:order_token) { "order_token" }
+
+    before do
+      allow(schema_context).to receive(:current_user).and_return(current_user)
+      allow(schema_context).to receive(:current_ability).and_return(current_ability)
+      allow(schema_context).to receive(:current_order).and_return(current_order)
+      allow(schema_context).to receive(:current_pricing_options).and_return(current_pricing_options)
+    end
+
+    it { is_expected.to be_an(Hash) }
+
+    it { is_expected.to have_key(:current_user) }
+    it { expect(subject[:current_user]).to eq current_user }
+
+    it { is_expected.to have_key(:current_ability) }
+    it { expect(subject[:current_ability]).to eq current_ability }
+
+    it { is_expected.to have_key(:current_store) }
+    it { expect(subject[:current_store]).to eq default_store }
+
+    it { is_expected.to have_key(:current_order) }
+    it { expect(subject[:current_order]).to eq current_order }
+
+    it { is_expected.to have_key(:current_pricing_options) }
+    it { expect(subject[:current_pricing_options]).to eq current_pricing_options }
+
+    it { is_expected.to have_key(:order_token) }
+    it { expect(subject[:order_token]).to eq order_token }
+  end
+
+  describe '#current_user' do
+    subject { schema_context.current_user }
+
+    context 'when headers do not contains the authorization token' do
+      it { is_expected.to be_nil }
+    end
+
+    context 'when headers contains the authorization token' do
+      let!(:user) { create(:user).tap(&:generate_spree_api_key!) }
+
+      context 'and the authorization token is invalid' do
+        let(:authorization_token) { 'wrongauthorizationtoken' }
+
+        it { is_expected.to be_nil }
+      end
+
+      context 'and the authorization token is valid' do
+        let(:authorization_token) { user.spree_api_key }
+
+        it { is_expected.to eq user }
+      end
+    end
+  end
+
+  describe '#current_ability' do
+    subject { schema_context.current_ability }
+
+    after { subject }
+
+    context 'when headers do not contains the authorization token' do
+      it { is_expected.to be_a Spree::Ability }
+      it { expect(Spree::Ability).to receive(:new).with(nil) }
+    end
+
+    context 'when headers contains the authorization token' do
+      let!(:user) { create(:user).tap(&:generate_spree_api_key!) }
+
+      context 'and the authorization token is invalid' do
+        let(:authorization_token) { 'wrongauthorizationtoken' }
+
+        it { is_expected.to be_a Spree::Ability }
+        it { expect(Spree::Ability).to receive(:new).with(nil) }
+      end
+
+      context 'and the authorization token is valid' do
+        let(:authorization_token) { user.spree_api_key }
+
+        it { is_expected.to be_a Spree::Ability }
+        it { expect(Spree::Ability).to receive(:new).with(user) }
+      end
+    end
+  end
+
+  describe '#current_store' do
+    subject { schema_context.current_store }
+
+    let!(:default_store) { create(:store, default: true) }
+
+    it { is_expected.to eq default_store }
+  end
+
+  describe '#current_pricing_options' do
+    subject { schema_context.current_pricing_options }
+
+    let(:default_currency) { 'EUR' }
+    let(:country_iso) { 'IT-it' }
+    let!(:default_store) do
+      create(:store, default: true, default_currency: default_currency, cart_tax_country_iso: country_iso)
+    end
+
+    it { is_expected.to be_a Spree::Config.pricing_options_class }
+
+    it do
+      expect(Spree::Config.pricing_options_class).to receive(:new).with(
+        currency: default_currency,
+        country_iso: country_iso
+      )
+      subject
+    end
+  end
+
+  describe '#order_token' do
+    subject { schema_context.order_token }
+
+    let(:order_token) { "order_token" }
+
+    it { is_expected.to eq order_token }
+  end
+
+  describe '#current_order' do
+    subject { schema_context.current_order }
+
+    let(:current_store) { create :store, default: true }
+
+    before do
+      allow(schema_context).to receive(:current_user).and_return(current_user)
+    end
+
+    context 'when there is a current user' do
+      let(:current_user) { create :user }
+
+      before do
+        allow(schema_context).to receive(:current_user).and_return(current_user)
+      end
+
+      context 'when the current user has one incompleted order in the current store' do
+        let!(:order) { create :order, user: current_user, store: current_store }
+
+        it { is_expected.to eq order }
+
+        context 'when is provided an order token for an incompleted order in the current store' do
+          let(:other_order) { create :order, store: current_store }
+          let(:order_token) { other_order.guest_token }
+
+          it { is_expected.to eq order }
+        end
+      end
+
+      context 'when the current user has many incompleted orders in the current store' do
+        let!(:first_created_order) { create :order, user: current_user, store: current_store, created_at: Time.zone.yesterday }
+        let!(:last_created_order) { create :order, user: current_user, store: current_store, created_at: Time.zone.today }
+
+        it { is_expected.to eq last_created_order }
+      end
+
+      context 'when the current user has one completed order in the current store' do
+        let!(:order) { create :completed_order_with_totals, user: current_user, store: current_store }
+
+        it { is_expected.to be_nil }
+      end
+
+      context 'when the current user has one incompleted order in another store' do
+        let(:other_store) { create :store, default: false }
+        let(:order) { create :order, user: current_user, store: other_store }
+
+        before do
+          current_store
+          order
+        end
+
+        it { is_expected.to be_nil }
+      end
+
+      context 'when the current user does not have any orders' do
+        it { is_expected.to be_nil }
+      end
+    end
+
+    context 'when there is no current user' do
+      let(:current_user) {}
+      let(:order_token) {}
+
+      context 'when is provided an order token for an incompleted order in the current store' do
+        let(:order) { create :order, store: current_store }
+        let(:order_token) { order.guest_token }
+
+        it { is_expected.to eq order }
+      end
+
+      context 'when is provided an order token for a completed order in the current store' do
+        let(:order) { create :completed_order_with_totals, store: current_store }
+        let(:order_token) { order.guest_token }
+
+        it { is_expected.to be_nil }
+      end
+
+      context 'when is provided an order token for an incompleted order in another store' do
+        let(:other_store) { create :store, default: false }
+        let(:order) { create :order, user: current_user, store: other_store }
+        let(:order_token) { order.guest_token }
+
+        before { current_store }
+
+        it { is_expected.to be_nil }
+      end
+
+      context 'when is provided no order token' do
+        it { is_expected.to be_nil }
+      end
+    end
+  end
+end