solidus_graphql_api 0.1.0

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe_mutation :complete_checkout, mutation: :complete_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][:completeCheckout]).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 isn't ready to be complete" do
+    let(:current_order) { create(:order_with_line_items) }
+
+    include_examples "responds with an unauthorized error"
+  end
+
+  context "when current order is ready to be complete" do
+    let(:current_order) { create(:order_ready_to_complete) }
+    let(:user_errors) { subject[:data][:completeCheckout][: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][:completeCheckout][:order] }
+
+      context 'and the given current order state can advance' 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('complete') }
+        it { expect(user_errors).to be_empty }
+        it { is_expected.to_not have_key(:errors) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe_mutation :next_checkout_state, mutation: :next_checkout_state 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][:nextCheckoutState]).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][:nextCheckoutState][: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][:nextCheckoutState][:order] }
+
+      context 'and the given current order state can advance' 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('address') }
+        it { expect(user_errors).to be_empty }
+        it { is_expected.to_not have_key(:errors) }
+      end
+
+      context "and the given current order state cannot advance" do
+        let(:confirm_state) { 'confirm' }
+
+        before { current_order.update(state: confirm_state) }
+
+        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
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe_mutation :select_shipping_rate, mutation: :select_shipping_rate 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(:shipping_rate_id) { 'U3ByZWU6OlNoaXBwaW5nUmF0ZS0xMDAw' }
+  let(:mutation_variables) {
+    Hash[
+      input: {
+        shippingRateId: shipping_rate_id
+      }
+    ]
+  }
+
+  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(:shipping_rate) { create(:shipping_rate, cost: 20) }
+    let(:user_errors) { subject[:data][:selectShippingRate][:errors] }
+
+    before do
+      current_order.shipments.first.shipping_rates << shipping_rate
+    end
+
+    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][:selectShippingRate][:order] }
+
+      context "when the given shipping rate id is wrong" do
+        it { expect(subject[:data][:selectShippingRate]).to be_nil }
+        it { expect(subject[:errors].first[:message]).to eq I18n.t(:'activerecord.exceptions.not_found') }
+      end
+
+      context "when there are errors during shipping rate selection" do
+        let(:selected_shipping_rate_id) { SolidusGraphqlApi::Schema.id_from_object(shipping_rate, nil, nil) }
+        let(:shipping_rate_id) { selected_shipping_rate_id }
+
+        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][:selectShippingRate]).to have_key(:errors) }
+      end
+
+      context "when the given shipping rate id is correct" do
+        let(:selected_shipping_rate_id) { SolidusGraphqlApi::Schema.id_from_object(shipping_rate, nil, nil) }
+        let(:shipping_rate_id) { selected_shipping_rate_id }
+
+        it "selects the correct shipping rate" do
+          shipping_rates = response_order[:shipments][:nodes].first[:shippingRates][:nodes]
+          selected_shipping_rate = shipping_rates.find { |shipping_rate| shipping_rate[:selected] }
+
+          expect( selected_shipping_rate[:id]).to eq(shipping_rate.id)
+        end
+      end
+    end
+  end
+end

data/spec/integration/mutations/create_order_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe_mutation :create_order, mutation: :create_order do
+  let(:current_user) { create(:user) }
+  let(:current_ability) { Spree::Ability.new(nil) }
+  let(:current_store) { create(:store) }
+  let(:mutation_context) {
+    Hash[
+      current_user: current_user,
+      current_ability: current_ability,
+      current_store: current_store
+    ]
+  }
+
+  let(:mutation_variables) {
+    Hash[
+      input: {}
+    ]
+  }
+
+  context 'when the current ability is unauthorized' do
+    before do
+      current_ability.cannot :create, Spree::Order
+    end
+
+    it { expect(subject[:data][:createOrder]).to be_nil }
+    it { expect(subject[:errors].first[:message]).to eq I18n.t(:"unauthorized.default") }
+  end
+
+  context 'when the current ability is authorized' do
+    let(:user_errors) { subject[:data][:createOrder][:errors] }
+    let(:response_order) { subject[:data][:createOrder][:order] }
+
+    context 'and the user is authenticated' do
+      let(:last_incomplete_order) { current_user.last_incomplete_spree_order(store: current_store) }
+
+      it { expect(response_order[:number]).to eq(last_incomplete_order.number) }
+      it { expect(response_order[:state]).to eq('cart') }
+      it { expect(user_errors).to be_empty }
+      it { is_expected.to_not have_key(:errors) }
+    end
+
+    context 'and the user is guest' do
+      let(:current_user) { nil }
+      let(:last_incomplete_order) { Spree::Order.incomplete.where(store: current_store).last }
+
+      it { expect(response_order[:number]).to eq(last_incomplete_order.number) }
+      it { expect(response_order[:state]).to eq('cart') }
+      it { expect(user_errors).to be_empty }
+      it { is_expected.to_not have_key(:errors) }
+    end
+  end
+end

data/spec/integration/mutations/empty_cart_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe_mutation :empty_cart, mutation: :empty_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(:mutation_variables) {
+    Hash[
+      input: {}
+    ]
+  }
+
+  shared_examples "responds with an unauthorized error" do
+    it { expect(subject[:data][:emptyCart]).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, state: 'address') }
+    let(:user_errors) { subject[:data][:emptyCart][: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][:emptyCart][:order] }
+
+      it { expect(response_order[:number]).to eq(current_order.number) }
+      it { expect(response_order[:state]).to eq('cart') }
+      it { expect(response_order[:lineItems][:nodes]).to be_empty }
+      it { expect(user_errors).to be_empty }
+      it { is_expected.to_not have_key(:errors) }
+    end
+  end
+end

data/spec/integration/mutations/mark_default_address_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe_mutation :mark_default_address, mutation: :mark_default_address do
+  let(:mutation_context) { Hash[current_ability: Spree::Ability.new(current_user), current_user: current_user] }
+  let(:mutation_variables) { Hash[input: { addressId: SolidusGraphqlApi::Schema.id_from_object(address, nil, nil) }] }
+
+  let(:current_user) { create(:user_with_addresses) }
+  let(:address) { create(:address) }
+
+  context "when current user isn't present" do
+    let(:current_user) { nil }
+
+    it { expect(subject[:data][:markDefaultAddress]).to be_nil }
+    it { expect(subject[:errors].first[:message]).to eq I18n.t(:"unauthorized.default") }
+  end
+
+  context "when current user is present" do
+    context "and the given address id is wrong" do
+      it { expect(subject[:data][:markDefaultAddress]).to be_nil }
+      it { expect(subject[:errors].first[:message]).to eq I18n.t(:'activerecord.exceptions.not_found') }
+    end
+
+    context "and the given address id is correct" do
+      before { current_user.addresses << address }
+
+      let(:default_address) { subject[:data][:markDefaultAddress][:user][:defaultAddress] }
+
+      it { expect(default_address[:id]).to eq address.id }
+    end
+  end
+end

data/spec/integration/mutations/remove_from_address_book_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe_mutation :remove_from_address_book, mutation: :remove_from_address_book do
+  let(:mutation_context) { Hash[current_ability: Spree::Ability.new(current_user), current_user: current_user] }
+  let(:mutation_variables) { Hash[input: { addressId: SolidusGraphqlApi::Schema.id_from_object(address, nil, nil) }] }
+
+  let(:address) { create(:address) }
+  let(:current_user) { create(:user_with_addresses) }
+
+  context "when current user isn't present" do
+    let(:current_user) { nil }
+
+    it { expect(subject[:data][:removeFromAddressBook]).to be_nil }
+    it { expect(subject[:errors].first[:message]).to eq I18n.t(:"unauthorized.default") }
+  end
+
+  context "when current user is present" do
+    context "and the given address id is wrong" do
+      it { expect(subject[:data][:removeFromAddressBook]).to be_nil }
+      it { expect(subject[:errors].first[:message]).to eq I18n.t(:"unauthorized.default") }
+    end
+
+    context "and the given address id is correct" do
+      before { current_user.addresses << address }
+
+      let(:user_addresses) { subject[:data][:removeFromAddressBook][:user][:addresses][:nodes] }
+
+      it { expect(user_addresses.count).to eq 2 }
+      it { expect(user_addresses.map{ |address| address[:id] }).to_not include(address.id) }
+
+      describe 'default address' do
+        let(:default_address) { subject[:data][:removeFromAddressBook][:user][:defaultAddress] }
+
+        context "when address is the default" do
+          before { current_user.mark_default_address(address.id) }
+
+          it { expect(default_address).to be_nil }
+        end
+
+        context "when address isn't the default" do
+          it { expect(default_address[:id]).to_not eq address.id }
+        end
+      end
+    end
+  end
+end

data/spec/integration/mutations/remove_from_cart_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe_mutation :remove_from_cart, mutation: :remove_from_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(:line_item) { current_order.line_items.first }
+  let(:line_item_id) {
+    SolidusGraphqlApi::Schema.id_from_object(line_item, nil, nil)
+  }
+  let(:mutation_variables) {
+    Hash[
+      input: {
+        lineItemId: line_item_id
+      }
+    ]
+  }
+
+  shared_examples "responds with an unauthorized error" do
+    it { expect(subject[:data][:removeFromCart]).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 }
+    let(:line_item_id) { 'not_existent' }
+
+    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, state: 'address') }
+    let(:user_errors) { subject[:data][:removeFromCart][: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][:removeFromCart][:order] }
+
+      it { expect(response_order[:number]).to eq(current_order.number) }
+      it { expect(response_order[:state]).to eq('cart') }
+      it { expect(response_order[:lineItems][:nodes]).to be_empty }
+      it { expect(user_errors).to be_empty }
+      it { is_expected.to_not have_key(:errors) }
+    end
+  end
+end