solidus_graphql_api 0.1.0

data/spec/integration/mutations/save_in_address_book_spec.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe_mutation :save_in_address_book, mutation: :save_in_address_book do
+  let(:default) { false }
+  let(:country_states_required) { false }
+  let(:address) { create(:address, firstname: "Jane", country: create(:country, states_required: country_states_required)) }
+  let(:address_attributes) {
+    {
+      firstname: address.firstname,
+      address1: address.address1,
+      city: address.city,
+      countryId: SolidusGraphqlApi::Schema.id_from_object(address.country, nil, nil),
+      phone: address.phone,
+      zipcode: address.zipcode,
+    }
+  }
+  let(:mutation_context) { Hash[current_ability: Spree::Ability.new(current_user), current_user: current_user] }
+  let(:mutation_variables) {
+    {
+      input: {
+        address: address_attributes,
+        default: default
+      }
+    }
+  }
+
+  context "when current user isn't present" do
+    let(:current_user) { nil }
+
+    it { expect(subject[:data][:saveInAddressBook]).to be_nil }
+    it { expect(subject[:errors].first[:message]).to eq I18n.t(:"unauthorized.default") }
+  end
+
+  context "when current user is present" do
+    let(:current_user) { create(:user) }
+    let(:default_address) { subject[:data][:saveInAddressBook][:user][:defaultAddress] }
+    let(:user_addresses) { subject[:data][:saveInAddressBook][:user][:addresses][:nodes] }
+    let(:user_errors) { subject[:data][:saveInAddressBook][:errors] }
+
+    context "when user doesn't have addresses" do
+      context "and given attributes are correct" do
+        it { expect(default_address[:firstname]).to eq(address[:firstname]) }
+        it { expect(user_addresses.count).to eq 1 }
+        it { expect(user_addresses.first[:firstname]).to eq(address[:firstname]) }
+        it { expect(user_errors).to be_empty }
+      end
+
+      context "and given attributes are incorrect" do
+        let(:country_states_required) { true }
+
+        it { expect(default_address).to be_nil }
+        it { expect(user_addresses.count).to eq 0 }
+        it { expect(user_errors.first[:path]).to eq ["input", "address", "state"] }
+        it { expect(user_errors.first[:message]).to eq "can't be blank" }
+      end
+    end
+
+    context "when user have addresses" do
+      let(:current_user) { create(:user_with_addresses) }
+
+      context "and given attributes are correct" do
+        it { expect(default_address).to_not be_nil }
+        it { expect(user_addresses.count).to eq 3 }
+        it { expect(user_addresses.map{ |address| address[:firstname] }).to include(address[:firstname]) }
+        it { expect(user_errors).to be_empty }
+
+        context 'when default false' do
+          it { expect(default_address[:firstname]).to_not eq(address[:firstname]) }
+        end
+
+        context 'when default true' do
+          let(:default) { true }
+
+          it { expect(default_address[:firstname]).to eq(address[:firstname]) }
+        end
+      end
+
+      context "and given attributes are incorrect" do
+        let(:country_states_required) { true }
+
+        it { expect(default_address).to_not be_nil }
+        it { expect(user_addresses.count).to eq 2 }
+        it { expect(user_errors.first[:path]).to eq ["input", "address", "state"] }
+        it { expect(user_errors.first[:message]).to eq "can't be blank" }
+      end
+    end
+  end
+end

data/spec/integration/mutations/set_order_email_spec.rb

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

data/spec/integration/mutations/update_cart_quantity_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe_mutation :update_cart_quantity, mutation: :update_cart_quantity 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(:quantity) { 10 }
+  let(:mutation_variables) {
+    Hash[
+      input: {
+        lineItemId: line_item_id,
+        quantity: quantity
+      }
+    ]
+  }
+
+  shared_examples "responds with an unauthorized error" do
+    it { expect(subject[:data][:updateCartQuantity]).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: 'delivery') }
+    let(:user_errors) { subject[:data][:updateCartQuantity][: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][:updateCartQuantity][: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[:id]).to eq(line_item.id) }
+      it { expect(response_order[:lineItems][:nodes].first[:quantity]).to eq(10) }
+      it { expect(user_errors).to be_empty }
+      it { is_expected.to_not have_key(:errors) }
+    end
+  end
+end

data/spec/integration/queries/completed_orders_spec.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe_query :completed_orders do
+  connection_field :completed_orders, query: :completed_orders, freeze_date: true do
+    let(:current_user) { create :user, email: 'email1@example.com' }
+    let(:query_context) { { current_user: current_user } }
+
+    context 'when there are not any completed orders' do
+      it { expect(subject.dig(:data, :completedOrders, :nodes)).to eq [] }
+    end
+
+    context 'when there are some completed orders' do
+      let(:order_1) do
+        create(
+          :completed_order_with_pending_payment,
+          id: 1,
+          user: current_user,
+          guest_token: 'fake guest token 1',
+          number: 'fake order number 1'
+        )
+      end
+      let(:order_2) do
+        create(
+          :completed_order_with_pending_payment,
+          id: 2,
+          user: current_user,
+          guest_token: 'fake guest token 2',
+          number: 'fake order number 2'
+        )
+      end
+      let!(:completed_orders) { [order_1, order_2] }
+
+      it { is_expected.to match_response('completed_orders') }
+    end
+
+    describe 'billing and shipping address fields' do
+      let(:ship_address_1_country) { create :country, id: 1 }
+      let(:ship_address_1_state) { create :state, id: 1, country: ship_address_1_country }
+      let(:bill_address_1_country) { create :country, id: 2 }
+      let(:bill_address_1_state) { create :state, id: 2, country: bill_address_1_country }
+      let(:ship_address_2_country) { create :country, id: 3 }
+      let(:ship_address_2_state) { create :state, id: 3, country: ship_address_2_country }
+      let(:bill_address_2_country) { create :country, id: 4 }
+      let(:bill_address_2_state) { create :state, id: 4, country: bill_address_2_country }
+      let(:ship_address_1) do
+        create(
+          :address,
+          id: 1,
+          zipcode: '10001',
+          address1: 'A Different Road',
+          country: ship_address_1_country,
+          state: ship_address_1_state
+        )
+      end
+      let(:bill_address_1) do
+        create(
+          :address,
+          id: 2,
+          zipcode: '10002',
+          address1: 'PO Box 1337',
+          country: bill_address_1_country,
+          state: bill_address_1_state
+        )
+      end
+      let(:ship_address_2) do
+        create(
+          :address,
+          id: 3,
+          zipcode: '10003',
+          address1: 'A Different Road',
+          country: ship_address_2_country,
+          state: ship_address_2_state
+        )
+      end
+      let(:bill_address_2) do
+        create(
+          :address,
+          id: 4,
+          zipcode: '10004',
+          address1: 'PO Box 1337',
+          country: bill_address_2_country,
+          state: bill_address_2_state
+        )
+      end
+      let(:order_1) do
+        create(
+          :completed_order_with_pending_payment,
+          id: 1,
+          user: current_user,
+          ship_address: ship_address_1,
+          bill_address: bill_address_1
+        )
+      end
+      let(:order_2) do
+        create(
+          :completed_order_with_pending_payment,
+          id: 2,
+          user: current_user,
+          ship_address: ship_address_2,
+          bill_address: bill_address_2
+        )
+      end
+      let!(:completed_orders) { [order_1, order_2] }
+
+      connection_field :shipping_address, query: 'completed_orders/shipping_address' do
+        it { is_expected.to match_response('completed_orders/shipping_address') }
+      end
+
+      connection_field :billing_address, query: 'completed_orders/billing_address' do
+        it { is_expected.to match_response('completed_orders/billing_address') }
+      end
+    end
+
+    connection_field :line_items, query: 'completed_orders/line_items' do
+      let!(:order) do
+        create :completed_order_with_pending_payment, id: 1, user: current_user, line_items_count: 2
+      end
+
+      it { is_expected.to match_response('completed_orders/line_items').with_args(line_items: order.line_items) }
+    end
+
+    connection_field :available_payment_methods, query: 'completed_orders/available_payment_methods' do
+      let!(:order) do
+        create :completed_order_with_pending_payment, id: 1, user: current_user
+      end
+
+      it { is_expected.to match_response('completed_orders/available_payment_methods').with_args(available_payment_methods: order.available_payment_methods) }
+    end
+
+    connection_field :payments, query: 'completed_orders/payments' do
+      let!(:order) { create :completed_order_with_pending_payment, id: 1, user: current_user }
+
+      it { is_expected.to match_response('completed_orders/payments').with_args(payments: order.payments) }
+    end
+
+    connection_field :adjustments, query: 'completed_orders/adjustments' do
+      let(:promotion) { create :promotion_with_order_adjustment, code: 'solidus' }
+      let(:promotion_code) { promotion.codes.first }
+
+      let(:tax_rate) { create :tax_rate }
+      let!(:tax_adjustment) { create :adjustment, source: tax_rate, order: order }
+
+      let!(:order) { create :completed_order_with_pending_payment, id: 1, user: current_user }
+
+      before do
+        promotion.actions.first.perform(
+          order: order,
+          promotion: promotion,
+          promotion_code: promotion_code
+        )
+      end
+
+      it { is_expected.to match_response('completed_orders/adjustments').with_args(adjustments: order.adjustments) }
+    end
+  end
+end

data/spec/integration/queries/countries_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe_query :countries, query: :countries, freeze_date: true do
+  connection_field :countries do
+    context 'when countries does not exists' do
+      it { expect(subject.dig(:data, :countries, :nodes)).to eq [] }
+    end
+
+    context 'when countries exists' do
+      let!(:us_country) { create(:country, :with_states, id: 1) }
+      let!(:it_country) { create(:country, id: 2, iso: 'IT') }
+
+      it { is_expected.to match_response(:countries) }
+    end
+  end
+end

data/spec/integration/queries/current_order_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe_query :currentOrder, query: :current_order, freeze_date: true do
+  let!(:order) { create :order_with_line_items, id: 1, number: 'fake number' }
+
+  let(:query_context) { { current_order: order } }
+  let(:shipment_number) { order.shipments.first.number }
+  let(:variant_sku) { order.line_items.first.variant.sku }
+
+  field :currentOrder do
+    it { is_expected.to match_response(:current_order).with_args(shipment_number: shipment_number, variant_sku: variant_sku) }
+  end
+end

data/spec/integration/queries/current_store_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe_query :currentStore, query: :current_store, freeze_date: true do
+  let!(:store) { create(:store, :with_defaults) }
+
+  before { Spree::Config.available_currencies = ::Money::Currency.first(2) }
+
+  let(:query_context) { Hash[current_store: store] }
+
+  field :currentStore do
+    it { is_expected.to match_response(:current_store) }
+  end
+end

data/spec/integration/queries/current_user_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe_query :current_user, query: :current_user, freeze_date: true do
+  let(:user) {
+    create(:user,
+           id: 1,
+           email: 'email@example.com',
+           spree_api_key: '123',
+           ship_address: ship_address,
+           bill_address: bill_address)
+  }
+
+  let(:ship_address) { create(:ship_address, id: 1, zipcode: 10_001) }
+  let(:bill_address) { create(:bill_address, id: 2, zipcode: 10_002) }
+  let(:credit_card) {
+    create(:credit_card,
+           user: user,
+           cc_type: 'visa',
+           address: ship_address,
+           payment_method: create(:payment_method, id: 1))
+  }
+
+  before do
+    wallet_payment_source = user.wallet.add credit_card
+    wallet_payment_source.update!(default: true)
+  end
+
+  field :currentUser do
+    context 'when context does not have current user' do
+      it { expect(subject.dig(:data, :currentUser)).to be_nil }
+    end
+
+    context 'when context have current user' do
+      let!(:query_context) { Hash[current_user: user] }
+
+      let(:args) { { wallet: user.wallet } }
+
+      it { is_expected.to match_response(:current_user).with_args(args) }
+    end
+  end
+end