solidus_graphql_api 0.1.0

data/spec/lib/solidus_graphql_api/queries/address/country_query_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::Address::CountryQuery do
+  subject { described_class.new(address: address).call.sync }
+
+  let(:address) { create(:address) }
+
+  let(:country) { address.country }
+
+  it { is_expected.to eq(country) }
+end

data/spec/lib/solidus_graphql_api/queries/address/state_query_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::Address::StateQuery do
+  subject { described_class.new(address: address).call.sync }
+
+  let(:address) { create(:address) }
+
+  let(:state) { address.state }
+
+  it { is_expected.to eq(state) }
+end

data/spec/lib/solidus_graphql_api/queries/completed_orders_query_spec.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::CompletedOrdersQuery do
+  subject { described_class.new(user: user).call }
+
+  let(:user) { create :user }
+  let!(:orders) { create_list(:completed_order_with_totals, 2, user: user) }
+
+  it { is_expected.to eq orders }
+end

data/spec/lib/solidus_graphql_api/queries/countries_query_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::CountriesQuery do
+  subject { described_class.new.call }
+
+  let!(:countries) { create_list(:country, 2) }
+
+  it { is_expected.to match_array(countries) }
+end

data/spec/lib/solidus_graphql_api/queries/country/states_query_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::Country::StatesQuery do
+  let(:country) { create(:country) }
+
+  let!(:states) { create_list(:state, 2, country: country) }
+
+  it { expect(described_class.new(country: country).call.sync).to match_array(states) }
+end

data/spec/lib/solidus_graphql_api/queries/line_item/variant_query_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::LineItem::VariantQuery do
+  let(:line_item) { create(:line_item) }
+
+  it { expect(described_class.new(line_item: line_item).call.sync).to eq(line_item.variant) }
+end

data/spec/lib/solidus_graphql_api/queries/option_type/option_values_query_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::OptionType::OptionValuesQuery do
+  let(:option_type) { create(:option_type) }
+
+  let!(:option_values) { create_list(:option_value, 2, option_type: option_type) }
+
+  it { expect(described_class.new(option_type: option_type).call.sync).to match_array(option_values) }
+end

data/spec/lib/solidus_graphql_api/queries/order/adjustments_query_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::Order::AdjustmentsQuery do
+  let(:promotion) { create :promotion_with_order_adjustment }
+  let(:order) { create :completed_order_with_promotion, promotion: promotion }
+
+  it { expect(described_class.new(order: order).call.sync).to eq order.adjustments }
+end

data/spec/lib/solidus_graphql_api/queries/order/billing_address_query_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::Order::BillingAddressQuery do
+  let(:order) { create :order, bill_address: billing_address }
+
+  let(:billing_address) { create :bill_address }
+
+  it { expect(described_class.new(order: order).call.sync).to eq billing_address }
+end

data/spec/lib/solidus_graphql_api/queries/order/line_items_query_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::Order::LineItemsQuery do
+  let(:order) { create :order_with_line_items, line_items_count: 2 }
+
+  it { expect(described_class.new(order: order).call.sync).to eq order.line_items }
+end

data/spec/lib/solidus_graphql_api/queries/order/payments_query_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::Order::PaymentsQuery do
+  let(:order) { create :completed_order_with_pending_payment }
+
+  it { expect(described_class.new(order: order).call.sync).to eq order.payments }
+end

data/spec/lib/solidus_graphql_api/queries/order/shipments_query_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::Order::ShipmentsQuery do
+  let(:order) { create :order }
+  let(:shipment) { create(:shipment) }
+
+  context 'when order has shipments' do
+    before { order.shipments << shipment }
+
+    it { expect(described_class.new(order: order).call.sync).to eq [shipment] }
+  end
+
+  context 'when order does not have shipments' do
+    it { expect(described_class.new(order: order).call.sync).to be_empty }
+  end
+end

data/spec/lib/solidus_graphql_api/queries/order/shipping_address_query_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::Order::ShippingAddressQuery do
+  let(:order) { create :order, ship_address: shipping_address }
+
+  let(:shipping_address) { create :ship_address }
+
+  it { expect(described_class.new(order: order).call.sync).to eq shipping_address }
+end

data/spec/lib/solidus_graphql_api/queries/product/master_variant_query_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::Product::MasterVariantQuery do
+  let(:product) { create(:product) }
+
+  let!(:variants) { create_list(:variant, 2, product: product) }
+
+  it { expect(described_class.new(product: product).call.sync).to eq(product.master) }
+end

data/spec/lib/solidus_graphql_api/queries/product/option_types_query_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::Product::OptionTypesQuery do
+  let(:product) { create(:product) }
+
+  let!(:option_types) { create_list(:option_type, 2, products: [product]) }
+
+  it { expect(described_class.new(product: product).call.sync).to match_array(option_types) }
+end

data/spec/lib/solidus_graphql_api/queries/product/product_properties_query_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::Product::ProductPropertiesQuery do
+  let(:product) { create(:product) }
+
+  let!(:product_properties) { create_list(:product_property, 2, product: product) }
+
+  it { expect(described_class.new(product: product).call.sync).to match_array(product_properties) }
+end

data/spec/lib/solidus_graphql_api/queries/product/variants_query_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::Product::VariantsQuery do
+  let(:product) { create(:product) }
+
+  let!(:variants) { create_list(:variant, 2, product: product) }
+
+  it { expect(described_class.new(product: product).call.sync).to match_array(variants) }
+end

data/spec/lib/solidus_graphql_api/queries/product_by_slug_query_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::ProductBySlugQuery do
+  subject { described_class.new.call(slug: slug) }
+
+  let!(:products) { create_list(:product, 2) }
+  let(:product) { products.last }
+  let(:slug) { product.slug }
+
+  it { is_expected.to eq(product) }
+end

data/spec/lib/solidus_graphql_api/queries/product_property/property_query_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::ProductProperty::PropertyQuery do
+  let(:property) { create(:property) }
+
+  let!(:product_property) { create(:product_property, property: property) }
+
+  it { expect(described_class.new(product_property: product_property).call.sync).to eq(property) }
+end

data/spec/lib/solidus_graphql_api/queries/products_query_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::ProductsQuery do
+  subject do
+    described_class.new(user: user, pricing_options: pricing_options).call(query: query)
+  end
+
+  let(:user) { create :user }
+  let(:pricing_options) { Spree::Config.pricing_options_class.new }
+  let(:query) { {} }
+
+  context 'when products do not exist' do
+    it { is_expected.to be_empty }
+  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) }
+    let!(:all_products) { [solidus_t_shirt, ruby_mug, solidus_mug, solidus_tote] }
+
+    context 'when no query is passed' do
+      it { is_expected.to match_array(all_products) }
+    end
+
+    context 'when a query is passed' do
+      let(:taxonomy) { create(:taxonomy, name: 'Categories') }
+      let(:t_shirts_taxon) { create(:taxon, name: 'T-Shirts', taxonomy: taxonomy, products: [solidus_t_shirt]) }
+      let(:mugs_taxon) { create(:taxon, name: 'Mugs', taxonomy: taxonomy, products: [ruby_mug, solidus_mug]) }
+      let(:totes_taxon) { create(:taxon, name: 'Totes', taxonomy: taxonomy, products: [solidus_tote]) }
+
+      let(:search) { { price_range_any: ["Under $10.00", "$15.00 - $18.00"] } }
+      let(:query) { { taxon: totes_taxon, keywords: "Solidus", search: search } }
+
+      it { is_expected.to match_array([solidus_tote]) }
+
+      context 'that contains page and/or per_page params' do
+        let(:query) { { keywords: "Solidus", page: 2, per_page: 2 } }
+
+        it 'ignores the page and per_page params' do
+          expect(subject).to match_array([solidus_t_shirt, solidus_mug, solidus_tote])
+        end
+      end
+    end
+  end
+end

data/spec/lib/solidus_graphql_api/queries/shipment/shipping_rates_query_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::Shipment::ShippingRatesQuery do
+  let(:shipment) { create(:shipment, shipping_rates: []) }
+  let(:shipping_rates) { shipment.shipping_rates }
+
+  context 'when shipment has shipping_rates' do
+    it { expect(described_class.new(shipment: shipment).call.sync).to eq shipping_rates }
+  end
+
+  context 'when shipment does not have shipping_rates' do
+    before { shipment.shipping_rates.destroy_all }
+
+    it { expect(described_class.new(shipment: shipment).call.sync).to be_empty }
+  end
+end

data/spec/lib/solidus_graphql_api/queries/taxon/children_query_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::Taxon::ChildrenQuery do
+  let(:taxon) { create(:taxon) }
+
+  let!(:children) { create_list(:taxon, 2, parent: taxon) }
+
+  it { expect(described_class.new(taxon: taxon).call.sync).to match_array(children) }
+end

data/spec/lib/solidus_graphql_api/queries/taxon/parent_taxon_query_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::Taxon::ParentTaxonQuery do
+  let(:parent_taxon) { create(:taxon) }
+  let(:taxon) { create(:taxon, parent: parent_taxon) }
+
+  it { expect(described_class.new(taxon: taxon).call.sync).to eq(parent_taxon) }
+end

data/spec/lib/solidus_graphql_api/queries/taxonomies_query_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::TaxonomiesQuery do
+  subject { described_class.new.call }
+
+  let!(:taxonomies) { create_list(:taxonomy, 2) }
+
+  it { is_expected.to match_array(taxonomies) }
+end

data/spec/lib/solidus_graphql_api/queries/taxonomy/root_taxon_query_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::Taxonomy::RootTaxonQuery do
+  let(:taxonomy) { create(:taxonomy) }
+  let(:root_taxon) { taxonomy.root }
+
+  it { expect(described_class.new(taxonomy: taxonomy).call.sync).to eq(root_taxon) }
+end

data/spec/lib/solidus_graphql_api/queries/taxonomy/taxons_query_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::Taxonomy::TaxonsQuery do
+  let(:taxons) { build_list(:taxon, 2) }
+
+  let(:taxonomy) { create(:taxonomy, taxons: taxons) }
+
+  it { expect(described_class.new(taxonomy: taxonomy).call.sync).to match_array(taxons) }
+end

data/spec/lib/solidus_graphql_api/queries/variant/default_price_query_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::Variant::DefaultPriceQuery do
+  let(:variant) { create(:variant) }
+
+  it { expect(described_class.new(variant: variant).call.sync).to eq(variant.default_price) }
+end

data/spec/lib/solidus_graphql_api/queries/variant/images_query_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::Variant::ImagesQuery do
+  let(:variant) { create(:variant) }
+
+  let!(:images) { create_list(:image, 2, viewable: variant ) }
+
+  it { expect(described_class.new(variant: variant).call.sync).to match_array(images) }
+end

data/spec/lib/solidus_graphql_api/queries/variant/option_values_query_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::Variant::OptionValuesQuery do
+  let(:variant) { create(:base_variant) }
+
+  let!(:option_values) { create_list(:option_value, 2, variants: [variant]) }
+
+  it { expect(described_class.new(variant: variant).call.sync).to match_array(option_values) }
+end

data/spec/lib/solidus_graphql_api/queries/variant/prices_query_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Queries::Variant::PricesQuery do
+  let(:variant) { create(:variant) }
+
+  let(:prices) { create_list(:price, 2, variant: variant) }
+
+  let!(:variant_prices) { [variant.default_price] + prices }
+
+  it { expect(described_class.new(variant: variant).call.sync).to match_array(variant_prices) }
+end

data/spec/lib/solidus_graphql_api/schema_spec.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusGraphqlApi::Schema do
+  it 'current schema is identical to expected schema' do
+    expected_schema = File.read("#{SolidusGraphqlApi::Engine.root}/spec/support/expected_schema.graphql")
+    current_schema = SolidusGraphqlApi::Schema.to_definition
+
+    result = GraphQL::SchemaComparator.compare(current_schema, expected_schema)
+
+    expect(result.identical?).to be_truthy, result.changes.map(&:message).join("\n")
+  end
+
+  describe '.id_from_object' do
+    subject { described_class.id_from_object(object, nil, nil) }
+
+    context 'when object responds to :id' do
+      let(:object) { build(:country, id: 1) }
+
+      after { subject }
+
+      it { expect(GraphQL::Schema::UniqueWithinType).to receive(:encode).with('Spree::Country', 1) }
+    end
+
+    context 'when object does not respond to :id' do
+      let(:object) { nil }
+
+      it { expect { subject }.to raise_error(NoMethodError) }
+    end
+  end
+
+  describe '.object_from_id' do
+    subject { described_class.object_from_id('ID', nil) }
+
+    let!(:object) { create(:country) }
+    let(:klass) { 'Spree::Country' }
+    let(:id) { object.id }
+
+    before do
+      allow(GraphQL::Schema::UniqueWithinType).to receive(:decode).and_return([klass, id])
+    end
+
+    context 'when the class and the id exist' do
+      it { is_expected.to eq object }
+    end
+
+    context 'when the class does not exist' do
+      let(:klass) { 'NotExistingClass' }
+
+      it { expect { subject }.to raise_error(NameError) }
+    end
+
+    context 'when the id does not exist' do
+      let(:id) { Spree::Country.maximum(:id).next }
+
+      it { expect { subject }.to raise_error(ActiveRecord::RecordNotFound) }
+    end
+  end
+
+  describe '.resolve_type' do
+    subject { described_class.resolve_type(nil, object, nil) }
+
+    context 'when graphql type exists' do
+      let(:object) { build(:country) }
+
+      # rubocop:disable Style/ClassAndModuleChildren
+      class SolidusGraphqlApi::Types::Country < SolidusGraphqlApi::Types::Base::RelayNode; end
+      # rubocop:enable Style/ClassAndModuleChildren
+
+      it { is_expected.to eq SolidusGraphqlApi::Types::Country }
+    end
+
+    context 'when graphql type does not exist' do
+      let(:object) { double(:not_existing) }
+
+      it { expect { subject }.to raise_error(NameError) }
+    end
+  end
+end