add create sell and buy crypto order mutations

spec/graphql/mutations/create_buy_crypto_order_spec.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe(Mutations::CreateBuyCryptoOrder, type: :mutation) do
+  let(:query_string) do
+    <<~GQL
+      mutation($currencyId: ID!, $amountCents: Int!) {
+        createBuyCryptoOrder(input: {
+          order: {
+            currencyId: $currencyId,
+            amountCents: $amountCents,
+          }
+        }) {
+          errors {
+            fullMessages
+            fieldName
+            messages
+            path
+          }
+          order {
+            status
+            paidAmountCents
+            receivedAmount
+            currency {
+              name
+            }
+          }
+        }
+      }
+    GQL
+  end
+
+  context "when the user has enough balance" do
+    it "withdraws from his account and creates a buy order" do
+      currency = create(:currency)
+      user = create(
+        :user,
+        fiat_balance: build(
+          :fiat_balance,
+          amount_cents: 100_00
+        ),
+      )
+
+      currency_global_id = GraphQL::Schema::UniqueWithinType.encode("Currency", currency.id)
+
+      variables = {
+        "currencyId": currency_global_id,
+        "amountCents": 90_00,
+      }
+
+      context = { current_user: user }
+
+      result = XStakeSchema.execute(
+        query_string,
+        variables: variables,
+        context: context
+      ).to_h.with_indifferent_access
+
+      expect(result).to(eq({
+        "data" => {
+          "createBuyCryptoOrder" => {
+            "errors" => nil,
+            "order" => {
+              "status" => "PROCESSING",
+              "paidAmountCents" => 90_00,
+              "receivedAmount" => nil,
+              "currency" => {
+                "name" => "CAKE",
+              },
+            },
+          },
+        },
+      }))
+
+      expect(user.fiat_balance.reload.amount_cents).to(eq(10_00))
+    end
+  end
+
+  context "when the user does not have enough balance" do
+    it "returns withdrawl error" do
+      currency = create(:currency)
+      user = create(
+        :user,
+        fiat_balance: build(
+          :fiat_balance,
+          amount_cents: 80_00
+        ),
+      )
+
+      currency_global_id = GraphQL::Schema::UniqueWithinType.encode("Currency", currency.id)
+
+      variables = {
+        "currencyId": currency_global_id,
+        "amountCents": 90_00,
+      }
+
+      context = { current_user: user }
+
+      result = XStakeSchema.execute(
+        query_string,
+        variables: variables,
+        context: context
+      ).to_h.with_indifferent_access
+
+      expect(result).to(eq({
+        "data" => {
+          "createBuyCryptoOrder" => {
+            "errors" => [{
+              "fullMessages" => ["Quantia saldo insuficiente"],
+              "fieldName" => "amount_cents",
+              "messages" => ["saldo insuficiente"],
+              "path" => ["attributes", "amount_cents"],
+            }],
+            "order" => nil,
+          },
+        },
+      }))
+    end
+  end
+end

spec/graphql/mutations/create_sell_crypto_order_spec.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe(Mutations::CreateSellCryptoOrder, type: :mutation) do
+  let(:query_string) do
+    <<~GQL
+      mutation($currencyId: ID!, $amount: String!) {
+        createSellCryptoOrder(input: {
+          order: {
+            currencyId: $currencyId,
+            amount: $amount,
+          }
+        }) {
+          errors {
+            fullMessages
+            fieldName
+            messages
+            path
+          }
+          order {
+            status
+            paidAmount
+            receivedAmountCents
+            currency {
+              name
+            }
+          }
+        }
+      }
+    GQL
+  end
+
+  context "when the user has enough balance" do
+    it "withdraws from his account and creates a buy order" do
+      currency = create(:currency)
+      user = create(
+        :user,
+        balances: [
+          build(:balance, currency: currency, amount: 1.0034),
+        ]
+      )
+
+      currency_global_id = GraphQL::Schema::UniqueWithinType.encode("Currency", currency.id)
+
+      variables = {
+        "currencyId": currency_global_id,
+        "amount": "0.80",
+      }
+
+      context = { current_user: user }
+
+      result = XStakeSchema.execute(
+        query_string,
+        variables: variables,
+        context: context
+      ).to_h.with_indifferent_access
+
+      expect(result).to(eq({
+        "data" => {
+          "createSellCryptoOrder" => {
+            "errors" => nil,
+            "order" => {
+              "status" => "PROCESSING",
+              "paidAmount" => "0.8",
+              "receivedAmountCents" => nil,
+              "currency" => {
+                "name" => "CAKE",
+              },
+            },
+          },
+        },
+      }))
+
+      expect(user.balances.first.reload.amount.to_s).to(eq("0.2034"))
+    end
+  end
+
+  context "when the user does not have enough balance" do
+    it "returns withdrawl error" do
+      currency = create(:currency)
+      user = create(
+        :user,
+        balances: [
+          build(:balance, currency: currency, amount: 0.0034),
+        ]
+      )
+
+      currency_global_id = GraphQL::Schema::UniqueWithinType.encode("Currency", currency.id)
+
+      variables = {
+        "currencyId": currency_global_id,
+        "amount": "0.80",
+      }
+
+      context = { current_user: user }
+
+      result = XStakeSchema.execute(
+        query_string,
+        variables: variables,
+        context: context
+      ).to_h.with_indifferent_access
+
+      expect(result).to(eq({
+        "data" => {
+          "createSellCryptoOrder" => {
+            "errors" => [{
+              "fullMessages" => ["Quantia saldo insuficiente"],
+              "fieldName" => "amount",
+              "messages" => ["saldo insuficiente"],
+              "path" => ["attributes", "amount"],
+            }],
+            "order" => nil,
+          },
+        },
+      }))
+
+      expect(user.balances.first.reload.amount.to_s).to(eq("0.0034"))
+    end
+  end
+end