solidus_graphql_api 0.1.0

data/solidus_graphql_api.gemspec

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'lib/solidus_graphql_api/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'solidus_graphql_api'
+  spec.version = SolidusGraphqlApi::VERSION
+  spec.authors = ['Christian Rimondi', 'Alessio Rocco', 'Rainer Dema']
+  spec.email = 'contact@solidus.io'
+
+  spec.summary = 'Solidus GraphQL API'
+  spec.description = 'GraphQL comes to Solidus'
+  spec.homepage = 'https://github.com/solidusio-contrib/solidus_graphql_api'
+  spec.license = 'BSD-3-Clause'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/solidusio-contrib/solidus_graphql_api'
+  spec.metadata['changelog_uri'] = 'https://github.com/solidusio-contrib/solidus_graphql_api/blob/master/CHANGELOG.md'
+
+  spec.required_ruby_version = Gem::Requirement.new('~> 2.5')
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  files = Dir.chdir(__dir__) { `git ls-files -z`.split("\x0") }
+
+  spec.files = files.grep_v(%r{^(test|spec|features)/})
+  spec.test_files = files.grep(%r{^(test|spec|features)/})
+  spec.bindir = "exe"
+  spec.executables = files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'batch-loader', '>= 1.4.1', '< 1.6.0'
+  spec.add_dependency 'graphql', '>= 1.10', '< 1.12'
+  spec.add_dependency 'solidus_core', ['>= 2.5', '< 3']
+  spec.add_dependency 'solidus_support', '~> 0.5'
+
+  spec.add_development_dependency 'graphql-schema_comparator', '~> 1.0.0'
+  spec.add_development_dependency 'pry', '~> 0.13.1'
+  spec.add_development_dependency 'simplecov', '~> 0.16.1'
+  spec.add_development_dependency 'solidus_dev_support', '~> 1.5.0'
+  spec.add_development_dependency 'timecop', '~> 0.9.1'
+  spec.add_development_dependency 'with_model', '~> 2.1.2'
+end

data/spec/integration/mutations/add_to_cart_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe_mutation :add_to_cart, mutation: :add_to_cart do
+  let(:current_ability) { Spree::Ability.new(nil) }
+  let(:guest_token) { nil }
+  let(:mutation_context) {
+    Hash[
+      current_ability: current_ability,
+      current_order: current_order,
+      order_token: guest_token
+    ]
+  }
+
+  let(:variant) { create(:variant) }
+  let(:variant_id) {
+    SolidusGraphqlApi::Schema.id_from_object(variant, nil, nil)
+  }
+  let(:quantity) { 10 }
+  let(:mutation_variables) {
+    Hash[
+      input: {
+        variantId: variant_id,
+        quantity: quantity
+      }
+    ]
+  }
+
+  shared_examples "responds with an unauthorized error" do
+    it { expect(subject[:data][:addToCart]).to be_nil }
+    it { expect(subject[:errors].first[:message]).to eq I18n.t(:"unauthorized.default") }
+  end
+
+  context "when current order isn't present" do
+    let(:current_order) { nil }
+
+    include_examples "responds with an unauthorized error"
+  end
+
+  context "when current order is completed" do
+    let(:current_order) { create(:completed_order_with_totals) }
+
+    include_examples "responds with an unauthorized error"
+  end
+
+  context "when current order isn't completed" do
+    let(:current_order) { create(:order, state: 'payment') }
+    let(:user_errors) { subject[:data][:addToCart][:errors] }
+
+    context 'and the current ability is unauthorized' do
+      include_examples "responds with an unauthorized error"
+    end
+
+    context 'and the current ability is authorized' do
+      let(:guest_token) { current_order.guest_token }
+      let(:response_order) { subject[:data][:addToCart][:order] }
+
+      it { expect(response_order[:number]).to eq(current_order.number) }
+      it { expect(response_order[:state]).to eq('address') }
+      it { expect(response_order[:lineItems][:nodes].first[:quantity]).to eq(10) }
+      it { expect(response_order[:lineItems][:nodes].first[:variant][:id]).to eq(variant.id) }
+      it { expect(user_errors).to be_empty }
+      it { is_expected.to_not have_key(:errors) }
+    end
+  end
+end

data/spec/integration/mutations/checkout/add_addresses_to_checkout_spec.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe_mutation :add_addresses_to_checkout, mutation: :add_addresses_to_checkout do
+  let(:current_ability) { Spree::Ability.new(nil) }
+  let(:guest_token) { nil }
+  let(:mutation_context) {
+    Hash[
+      current_ability: current_ability,
+      current_order: current_order,
+      order_token: guest_token
+    ]
+  }
+
+  let(:country_id) { SolidusGraphqlApi::Schema.id_from_object(create(:country), nil, nil) }
+  let(:address) {
+    address = build_stubbed(:address).slice(:address1, :city, :phone, :zipcode)
+    address[:countryId] = country_id
+    address.transform_keys! { |key| key.camelize(:lower) }
+  }
+  let(:billing_address_firstname) { 'John' }
+  let(:shipping_address_firstname) { 'Jane' }
+  let(:mutation_variables) {
+    Hash[
+      input: {
+        billingAddress: address.merge(firstname: billing_address_firstname),
+        shippingAddress: address.merge(firstname: shipping_address_firstname)
+      }
+    ].tap do |variables|
+      variables[:input][:shipToBillingAddress] = ship_to_billing_address if defined?(ship_to_billing_address)
+    end
+  }
+
+  shared_examples "responds with an unauthorized error" do
+    it { expect(subject[:data][:addAddressesToCheckout]).to be_nil }
+    it { expect(subject[:errors].first[:message]).to eq I18n.t(:"unauthorized.default") }
+  end
+
+  context "when current order isn't present" do
+    let(:current_order) { nil }
+
+    include_examples "responds with an unauthorized error"
+  end
+
+  context "when current order is completed" do
+    let(:current_order) { create(:completed_order_with_totals) }
+
+    include_examples "responds with an unauthorized error"
+  end
+
+  context "when current order isn't completed" do
+    let(:current_order) { create(:order_with_line_items) }
+    let(:user_errors) { subject[:data][:addAddressesToCheckout][:errors] }
+
+    context 'and the current ability is unauthorized' do
+      include_examples "responds with an unauthorized error"
+    end
+
+    context 'and the current ability is authorized' do
+      let(:guest_token) { current_order.guest_token }
+      let(:response_order) { subject[:data][:addAddressesToCheckout][:order] }
+
+      context 'with wrong arguments' do
+        let(:billing_address_firstname) { '' }
+
+        it { expect(response_order[:number]).to eq(current_order.number) }
+
+        if Gem::Requirement.new('>= 2.11.0.alpha').satisfied_by?(Spree.solidus_gem_version)
+          it { expect(user_errors.first[:path]).to eq(["input", "order", "billAddress", "name"]) }
+        else
+          it { expect(user_errors.first[:path]).to eq(["input", "order", "billAddress", "firstname"]) }
+        end
+
+        it { expect(user_errors.first[:message]).to eq("can't be blank") }
+        it { is_expected.to_not have_key(:errors) }
+      end
+
+      context 'with correct arguments' do
+        context 'when shipToBillingAddress argument' do
+          describe 'is true' do
+            let(:ship_to_billing_address) { true }
+
+            it { expect(response_order[:number]).to eq(current_order.number) }
+            it { expect(response_order[:state]).to eq('address') }
+            it { expect(response_order[:billingAddress][:firstname]).to eq(billing_address_firstname) }
+            it { expect(response_order[:shippingAddress][:firstname]).to eq(billing_address_firstname) }
+            it { expect(user_errors).to be_empty }
+            it { is_expected.to_not have_key(:errors) }
+          end
+
+          describe 'is false' do
+            let(:ship_to_billing_address) { false }
+
+            it { expect(response_order[:number]).to eq(current_order.number) }
+            it { expect(response_order[:state]).to eq('address') }
+            it { expect(response_order[:billingAddress][:firstname]).to eq(billing_address_firstname) }
+            it { expect(response_order[:shippingAddress][:firstname]).to eq(shipping_address_firstname) }
+            it { expect(user_errors).to be_empty }
+            it { is_expected.to_not have_key(:errors) }
+          end
+
+          describe 'is not present' do
+            it { expect(response_order[:number]).to eq(current_order.number) }
+            it { expect(response_order[:state]).to eq('address') }
+            it { expect(response_order[:billingAddress][:firstname]).to eq(billing_address_firstname) }
+            it { expect(response_order[:shippingAddress][:firstname]).to eq(shipping_address_firstname) }
+            it { expect(user_errors).to be_empty }
+            it { is_expected.to_not have_key(:errors) }
+          end
+        end
+      end
+    end
+  end
+end

data/spec/integration/mutations/checkout/add_payment_to_checkout_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe_mutation :add_payment_to_checkout, mutation: :add_payment_to_checkout do
+  let(:current_ability) { Spree::Ability.new(nil) }
+  let(:guest_token) { nil }
+  let(:mutation_context) {
+    Hash[
+      current_ability: current_ability,
+      current_order: current_order,
+      order_token: guest_token
+    ]
+  }
+
+  let(:payment_method_id) { "U3ByZWU6OlBheW1lbnRNZXRob2QtMTAwMg==" }
+  let(:amount) { 10 }
+  let(:source) { Hash[] }
+  let(:mutation_variables) {
+    Hash[
+      input: {
+        paymentMethodId: payment_method_id,
+        amount: amount,
+        source: source
+      }
+    ]
+  }
+
+  shared_examples "responds with an unauthorized error" do
+    it { expect(subject[:data][:selectShippingRate]).to be_nil }
+    it { expect(subject[:errors].first[:message]).to eq I18n.t(:"unauthorized.default") }
+  end
+
+  context "when current order isn't present" do
+    let(:current_order) { nil }
+
+    include_examples "responds with an unauthorized error"
+  end
+
+  context "when current order is completed" do
+    let(:current_order) { create(:order_with_line_items) }
+
+    include_examples "responds with an unauthorized error"
+  end
+
+  context "when current order isn't completed" do
+    let(:current_order) { create(:order_with_line_items) }
+    let(:user_errors) { subject[:data][:addPaymentToCheckout][:errors] }
+    let!(:payment_method) { create(:check_payment_method) }
+
+    context 'and the current ability is unauthorized' do
+      include_examples "responds with an unauthorized error"
+    end
+
+    context 'and the current ability is authorized' do
+      let(:guest_token) { current_order.guest_token }
+      let(:response_order) { subject[:data][:addPaymentToCheckout][:order] }
+
+      context "when the given payment method id is wrong" do
+        it { expect(subject[:data][:addPaymentToCheckout]).to be_nil }
+        it { expect(subject[:errors].first[:message]).to eq I18n.t(:'activerecord.exceptions.not_found') }
+      end
+
+      context "when there are errors during payment method selection" do
+        let(:payment_method_id) { SolidusGraphqlApi::Schema.id_from_object(payment_method, nil, nil) }
+
+        before do
+          order_updater = instance_double('Spree::OrderUpdateAttributes', apply: false)
+          allow(Spree::OrderUpdateAttributes).to receive(:new).and_return(order_updater)
+        end
+
+        it { expect(subject[:data][:addPaymentToCheckout]).to have_key(:errors) }
+      end
+
+      context "when the given payment method id is correct" do
+        let(:payment_method_id) { SolidusGraphqlApi::Schema.id_from_object(payment_method, nil, nil) }
+
+        it "add a payment source to the order" do
+          aggregate_failures do
+            expect(response_order[:number]).to eq(current_order.number)
+            expect(user_errors).to be_empty
+          end
+        end
+      end
+    end
+  end
+end

data/spec/integration/mutations/checkout/advance_checkout_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe_mutation :advance_checkout, mutation: :advance_checkout do
+  let(:current_ability) { Spree::Ability.new(nil) }
+  let(:guest_token) { nil }
+  let(:mutation_context) {
+    Hash[
+      current_ability: current_ability,
+      current_order: current_order,
+      order_token: guest_token
+    ]
+  }
+
+  let(:mutation_variables) { Hash[input: {}] }
+
+  shared_examples "responds with an unauthorized error" do
+    it { expect(subject[:data][:advanceCheckout]).to be_nil }
+    it { expect(subject[:errors].first[:message]).to eq I18n.t(:"unauthorized.default") }
+  end
+
+  context "when current order isn't present" do
+    let(:current_order) { nil }
+
+    include_examples "responds with an unauthorized error"
+  end
+
+  context "when current order is valid" do
+    let(:current_order) { create(:order_with_line_items) }
+    let(:user_errors) { subject[:data][:advanceCheckout][:errors] }
+
+    context 'and the current ability is unauthorized' do
+      include_examples "responds with an unauthorized error"
+    end
+
+    context 'and the current ability is authorized' do
+      let(:guest_token) { current_order.guest_token }
+      let(:response_order) { subject[:data][:advanceCheckout][:order] }
+      let(:confirm_state) { 'confirm' }
+      let(:address_state) { 'address' }
+
+      shared_examples "responds with the current order in confirm state" do
+        it { expect(response_order[:number]).to eq(current_order.number) }
+        it { expect(response_order[:email]).to eq(current_order.email) }
+        it { expect(response_order[:state]).to eq(confirm_state) }
+        it { expect(user_errors.first[:path]).to eq(["input", "order", "state"]) }
+        it { expect(user_errors.first[:message]).to eq("cannot transition via \"next\"") }
+        it { is_expected.to_not have_key(:errors) }
+      end
+
+      context 'when current order state' do
+        describe 'is cart' do
+          include_examples "responds with the current order in confirm state"
+        end
+
+        describe 'is address' do
+          before { current_order.update(state: address_state) }
+
+          include_examples "responds with the current order in confirm state"
+        end
+      end
+
+      context "and the given current order state cannot advance" do
+        before { current_order.update(state: confirm_state) }
+
+        include_examples "responds with the current order in confirm state"
+      end
+    end
+  end
+end

data/spec/integration/mutations/checkout/apply_coupon_code_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe_mutation :apply_coupon_code, mutation: :apply_coupon_code do
+  let(:current_ability) { Spree::Ability.new(nil) }
+  let(:guest_token) { nil }
+  let(:mutation_context) {
+    Hash[
+      current_ability: current_ability,
+      current_order: current_order,
+      order_token: guest_token
+    ]
+  }
+
+  let(:coupon_code) { 'coupon_code' }
+  let(:mutation_variables) {
+    Hash[
+      input: {
+        couponCode: coupon_code
+      }
+    ]
+  }
+
+  shared_examples "responds with an unauthorized error" do
+    it { expect(subject[:data][:selectShippingRate]).to be_nil }
+    it { expect(subject[:errors].first[:message]).to eq I18n.t(:"unauthorized.default") }
+  end
+
+  context "when current order isn't present" do
+    let(:current_order) { nil }
+
+    include_examples "responds with an unauthorized error"
+  end
+
+  context "when current order is completed" do
+    let(:current_order) { create(:completed_order_with_totals) }
+
+    include_examples "responds with an unauthorized error"
+  end
+
+  context "when current order isn't completed" do
+    let(:current_order) { create(:order_with_line_items) }
+    let(:user_errors) { subject[:data][:applyCouponCode][:errors] }
+
+    context 'and the current ability is unauthorized' do
+      include_examples "responds with an unauthorized error"
+    end
+
+    context 'and the current ability is authorized' do
+      let(:guest_token) { current_order.guest_token }
+      let(:response_order) { subject[:data][:applyCouponCode][:order] }
+
+      context "and the given coupon code is applicable" do
+        let(:flat_rate_discount) { 10.0 }
+
+        before { create(:promotion, :with_line_item_adjustment, adjustment_rate: flat_rate_discount, code: coupon_code) }
+
+        it { expect(response_order[:adjustmentTotal]).to eq((-flat_rate_discount).to_s) }
+        it { expect(response_order[:number]).to eq(current_order.number) }
+        it { expect(response_order[:email]).to eq(current_order.email) }
+        it { expect(user_errors).to be_empty }
+        it { is_expected.to_not have_key(:errors) }
+      end
+
+      context "and the given coupon code doesn't exist" do
+        it { expect(response_order[:adjustmentTotal].to_d).to be_zero }
+        it { expect(response_order[:number]).to eq(current_order.number) }
+        it { expect(response_order[:email]).to eq(current_order.email) }
+        it { expect(user_errors.first[:path]).to eq(["input", "order", "couponCode"]) }
+        it { expect(user_errors.first[:message]).to eq("The coupon code you entered doesn't exist. Please try again.") }
+        it { is_expected.to_not have_key(:errors) }
+      end
+    end
+  end
+end