stellar-base 0.21.0 → 0.23.0

data/spec/lib/stellar/operation_spec.rb

@@ -1,133 +0,0 @@
-require 'spec_helper'
-
-describe Stellar::Operation, ".payment" do
-
-
-  it "correctly translates the provided amount to the native representation" do
-    op = Stellar::Operation.payment(destination: Stellar::KeyPair.random, amount: [:native, 20])
-    expect(op.body.value.amount).to eql(20_0000000)
-    op = Stellar::Operation.payment(destination: Stellar::KeyPair.random, amount: [:native, "20"])
-    expect(op.body.value.amount).to eql(20_0000000)
-  end
-
-end
-
-def pk_to_address(pk)
-  Stellar::Convert.pk_to_address(pk)
-end
-
-describe "path payment operations" do
-  let(:destination){ Stellar::KeyPair.random }
-  let(:send_asset_issuer){ Stellar::KeyPair.master }
-  let(:send_asset){ Stellar::Asset.alphanum4("USD", send_asset_issuer) }
-  let(:dest_asset_issuer){ Stellar::KeyPair.master }
-  let(:dest_asset){ Stellar::Asset.alphanum4("EUR", dest_asset_issuer) }
-  let(:amount){ [:alphanum4, dest_asset.code, dest_asset_issuer, 9.2] }
-  let(:with){ [:alphanum4, send_asset.code, send_asset_issuer, 10] }
-  
-  describe Stellar::Operation, ".path_payment" do
-    it "works" do
-      destination = Stellar::KeyPair.random
-      amount = [:alphanum4, "USD", Stellar::KeyPair.master, 10]    
-      with = [:alphanum4, "EUR", Stellar::KeyPair.master, 9.2]
-
-      op = Stellar::Operation.path_payment(
-        destination: destination,
-        amount: amount,
-        with: with
-      )
-
-      expect(op.body.arm).to eql(:path_payment_strict_receive_op)
-    end
-  end
-
-  describe Stellar::Operation, ".path_payment_strict_receive" do
-    it "works" do
-      op = Stellar::Operation.path_payment_strict_receive(
-        destination: destination,
-        amount: amount,
-        with: with
-      )
-
-      expect(op.body.arm).to eql(:path_payment_strict_receive_op)
-      expect(op.body.value.destination).to eql(destination.public_key)
-      expect(op.body.value.send_asset).to eql(send_asset)
-      expect(op.body.value.dest_asset).to eql(dest_asset)
-      expect(op.body.value.send_max).to eq(100000000)
-      expect(op.body.value.dest_amount).to eq(92000000)
-    end
-  end
-
-  describe Stellar::Operation, ".path_payment_strict_send" do
-    it "works" do
-      op = Stellar::Operation.path_payment_strict_send(
-        destination: destination,
-        amount: amount,
-        with: with
-      )
-
-      expect(op.body.arm).to eql(:path_payment_strict_send_op)
-      expect(op.body.value.destination).to eql(destination.public_key)
-      expect(op.body.value.send_asset).to eql(send_asset)
-      expect(op.body.value.dest_asset).to eql(dest_asset)
-      expect(op.body.value.send_amount).to eq(100000000)
-      expect(op.body.value.dest_min).to eq(92000000)
-    end
-  end
-end
-
-describe Stellar::Operation, ".manage_data" do
-
-  it "works" do
-    op = Stellar::Operation.manage_data(name: "my name", value: "hello")
-    expect(op.body.manage_data_op!.data_name).to eql("my name")
-    expect(op.body.manage_data_op!.data_value).to eql("hello")
-    expect{ op.to_xdr }.to_not raise_error
-
-    op = Stellar::Operation.manage_data(name: "my name")
-    expect(op.body.manage_data_op!.data_name).to eql("my name")
-    expect(op.body.manage_data_op!.data_value).to be_nil
-    expect{ op.to_xdr }.to_not raise_error
-  end
-
-end
-
-describe Stellar::Operation, ".change_trust" do
-
-  let(:issuer) { Stellar::KeyPair.from_address("GDGU5OAPHNPU5UCLE5RDJHG7PXZFQYWKCFOEXSXNMR6KRQRI5T6XXCD7") }
-  let(:asset) { Stellar::Asset.alphanum4("USD", issuer) }
-
-  it "creates a ChangeTrustOp" do
-    op = Stellar::Operation.change_trust(line: [:alphanum4, "USD", issuer])
-    expect(op.body.value).to be_an_instance_of(Stellar::ChangeTrustOp)
-    expect(op.body.value.line).to eq(Stellar::Asset.alphanum4("USD", issuer))
-    expect(op.body.value.limit).to eq(9223372036854775807)
-  end
-
-  it "creates a ChangeTrustOp with an asset" do
-    asset = Stellar::Asset.alphanum4("USD", issuer)
-    op = Stellar::Operation.change_trust(line: asset, limit: 1234.75)
-    expect(op.body.value).to be_an_instance_of(Stellar::ChangeTrustOp)
-    expect(op.body.value.line).to eq(Stellar::Asset.alphanum4("USD", issuer))
-    expect(op.body.value.limit).to eq(12347500000)
-  end
-
-  it "only allow sound `line` arguments" do
-    expect {
-      Stellar::Operation.change_trust(line: [:harmful_call, "USD", issuer])
-    }.to raise_error(ArgumentError, "must be one of #{Stellar::Asset::TYPES}")
-  end
-
-  it "creates a ChangeTrustOp with limit" do
-    op = Stellar::Operation.change_trust(line: [:alphanum4, "USD", issuer], limit: 1234.75)
-    expect(op.body.value).to be_an_instance_of(Stellar::ChangeTrustOp)
-    expect(op.body.value.line).to eq(Stellar::Asset.alphanum4("USD", issuer))
-    expect(op.body.value.limit).to eq(12347500000)
-  end
-
-  it "throws ArgumentError for incorrect limit argument" do
-    expect {
-      Stellar::Operation.change_trust(line: [:alphanum4, "USD", issuer], limit: true)
-    }.to raise_error(ArgumentError)
-  end
-end

data/spec/lib/stellar/path_payment_strict_receive_result_spec.rb

@@ -1,95 +0,0 @@
-require "spec_helper"
-
-describe Stellar::PathPaymentStrictReceiveResult, "#send_amount" do
-
-
-  context "when the result is not successful" do
-    subject{ Stellar::PathPaymentStrictReceiveResult.new(:path_payment_strict_receive_malformed) }
-
-    it "raises an exception if the result is not successful" do
-      expect{ subject.send_amount }.to raise_error(XDR::ArmNotSetError)
-    end
-  end
-
-  context "when the result has no claimed offers" do
-    let(:simple_success){ Stellar::SimplePaymentResult.new(amount: 100) }
-    let(:path_success){ Stellar::PathPaymentStrictReceiveResult::Success.new(last: simple_success) }
-
-    subject{ Stellar::PathPaymentStrictReceiveResult.new(:path_payment_strict_receive_success, path_success) }
-
-    it "returns the amount from the 'last' component" do
-      expect(subject.send_amount).to eql(100)
-    end
-  end
-
-
-  context "with simple 1-hop result" do
-    let(:simple_success){ Stellar::SimplePaymentResult.new(amount: 100) }
-    let(:offers) do
-      [Stellar::ClaimOfferAtom.new(asset_bought: Stellar::Asset.native, amount_bought: 200)]
-    end
-
-    let(:path_success) do
-      Stellar::PathPaymentStrictReceiveResult::Success.new({
-        offers: offers,
-        last:   simple_success,
-      })
-    end
-
-    subject{ Stellar::PathPaymentStrictReceiveResult.new(:path_payment_strict_receive_success, path_success) }
-
-    it "returns the amount from the ClaimOfferAtom" do
-      expect(subject.send_amount).to eql(200)
-    end
-  end
-
-  context "with 1-hop result that claimed multiple offers" do
-    let(:simple_success){ Stellar::SimplePaymentResult.new(amount: 100) }
-    let(:offers) do
-      [
-        Stellar::ClaimOfferAtom.new(asset_bought: Stellar::Asset.native, amount_bought: 200),
-        Stellar::ClaimOfferAtom.new(asset_bought: Stellar::Asset.native, amount_bought: 200),
-      ]
-    end
-
-    let(:path_success) do
-      Stellar::PathPaymentStrictReceiveResult::Success.new({
-        offers: offers,
-        last:   simple_success,
-      })
-    end
-
-    subject{ Stellar::PathPaymentStrictReceiveResult.new(:path_payment_strict_receive_success, path_success) }
-
-    it "returns the summed amount from the ClaimOfferAtoms" do
-      expect(subject.send_amount).to eql(400)
-    end
-  end
-
-
-  context "with multi-hop result that claimed multiple offers" do
-    let(:simple_success){ Stellar::SimplePaymentResult.new(amount: 100) }
-    let(:otherAsset){ Stellar::Asset.alphanum4("USD", Stellar::KeyPair.random) }
-    let(:offers) do
-      [
-        Stellar::ClaimOfferAtom.new(asset_bought: Stellar::Asset.native, amount_bought: 200),
-        Stellar::ClaimOfferAtom.new(asset_bought: Stellar::Asset.native, amount_bought: 200),
-        Stellar::ClaimOfferAtom.new(asset_bought: otherAsset, amount_bought: 200),
-      ]
-    end
-
-    let(:path_success) do
-      Stellar::PathPaymentStrictReceiveResult::Success.new({
-        offers: offers,
-        last:   simple_success,
-      })
-    end
-
-    subject{ Stellar::PathPaymentStrictReceiveResult.new(:path_payment_strict_receive_success, path_success) }
-
-    it "returns the summed amount from the ClaimOfferAtoms" do
-      expect(subject.send_amount).to eql(400)
-    end
-  end
-
-end

data/spec/lib/stellar/price_spec.rb

@@ -1,34 +0,0 @@
-require "spec_helper"
-
-describe Stellar::Price, "#from_f" do
-  subject{ Stellar::Price }
-  let(:seed){ 225571644875421139403973254661022579608 } #generated using Random.new
-  let(:random){ Random.new(seed) } 
-  let(:iterations){ ENV["SMOKE_ITERATIONS"].present? ? ENV["SMOKE_ITERATIONS"].to_i : 2000}
-
-  it "withstands a random smoke test" do
-    iterations.times do |i|
-      expected = random.rand
-      actual_p = subject.from_f(expected)
-      actual = actual_p.to_f
-
-      expect(actual).to be_within(0.000000001).of(actual)
-      expect(actual_p.n).to be <= Stellar::Price::MAX_PRECISION
-      expect(actual_p.d).to be <= Stellar::Price::MAX_PRECISION
-    end
-  end
-
-  it "works with bigdecimal" do
-      whole      = random.rand(1_000_000)
-      fractional = random.rand(10_000_000) # seven significant digits available for fractional
-      
-      expected = BigDecimal("#{whole}.#{fractional}")
-      actual_p = subject.from_f(expected)
-      actual = BigDecimal(actual_p.n) / BigDecimal(actual_p.d)
-
-      expect(actual).to be_within(BigDecimal("0.000000001")).of(actual)
-      expect(actual_p.n).to be <= Stellar::Price::MAX_PRECISION
-      expect(actual_p.d).to be <= Stellar::Price::MAX_PRECISION
-  end
-
-end

data/spec/lib/stellar/signer_key_spec.rb

@@ -1,26 +0,0 @@
-require "spec_helper"
-
-describe Stellar::SignerKey, ".hash_x" do
-
-  subject{ Stellar::SignerKey }
-
-  let(:hash_preimage){ "a" * 32 }
-  let(:hash){ Digest::SHA256.digest(hash_preimage) }
-
-  it "raises an argument error when not provided a 32-byte string" do
-    expect{subject.hash_x("hello world")}.to raise_error(ArgumentError)
-    expect{subject.hash_x("")}.to raise_error(ArgumentError)
-    expect{subject.hash_x("a" * 31)}.to raise_error(ArgumentError)
-    expect{subject.hash_x("a" * 33)}.to raise_error(ArgumentError)
-    expect{subject.hash_x([0] * 32)}.to raise_error(ArgumentError)
-
-  end
-
-  it "creates a HashX signer key" do
-    sk = subject.hash_x(hash_preimage)
-    expect(sk.switch).to eq(Stellar::SignerKeyType.signer_key_type_hash_x)
-    expect(sk.value).to be_an_instance_of(String)
-    expect(sk.value).to eq(hash)
-  end
-
-end

data/spec/lib/stellar/thresholds_spec.rb

@@ -1,62 +0,0 @@
-require 'spec_helper'
-
-describe Stellar::Thresholds, ".parse" do
-  subject{ Stellar::Thresholds }
-  let(:raw)    { "\x01\x02\x03\x04" }
-  let(:result) { subject.parse raw }
-
-  it "sets master_weight as the 1st byte" do
-    expect(result[:master_weight]).to eq(1)
-  end
-
-  it "sets low as the 2nd byte" do
-    expect(result[:low]).to eq(2)
-  end
-
-  it "sets medium as the 3rd byte" do
-    expect(result[:medium]).to eq(3)
-  end
-
-  it "sets high as the 4th byte" do
-    expect(result[:high]).to eq(4)
-  end
-end
-
-describe Stellar::Thresholds, ".make" do
-  subject{ Stellar::Thresholds }
-  let(:good){{master_weight: 1, low: 2, medium: 3, high: 4}}
-
-  it "works" do
-    expect(subject.make(good)).to eq("\x01\x02\x03\x04")
-  end
-
-  it "errors unless all components are provided" do
-    expect{ subject.make(good.except(:master_weight)) }.to raise_error(ArgumentError)
-    expect{ subject.make(good.except(:low)) }.to raise_error(ArgumentError)
-    expect{ subject.make(good.except(:medium)) }.to raise_error(ArgumentError)
-    expect{ subject.make(good.except(:high)) }.to raise_error(ArgumentError)
-  end
-
-  it "errors unless all components are numbers" do
-    expect{ subject.make(good.merge(master_weight: "hello")) }.to raise_error(ArgumentError)
-    expect{ subject.make(good.merge(low: "hello")) }.to raise_error(ArgumentError)
-    expect{ subject.make(good.merge(medium: "hello")) }.to raise_error(ArgumentError)
-    expect{ subject.make(good.merge(high: "hello")) }.to raise_error(ArgumentError)
-  end
-
-  it "errors unless all components are in (0..255)" do
-    expect{ subject.make(good.merge(master_weight: -1)) }.to raise_error(ArgumentError)
-    expect{ subject.make(good.merge(master_weight: 256)) }.to raise_error(ArgumentError)
-    expect{ subject.make(good.merge(low: -1)) }.to raise_error(ArgumentError)
-    expect{ subject.make(good.merge(low: 256)) }.to raise_error(ArgumentError)
-    expect{ subject.make(good.merge(medium: -1)) }.to raise_error(ArgumentError)
-    expect{ subject.make(good.merge(medium: 256)) }.to raise_error(ArgumentError)
-    expect{ subject.make(good.merge(high: -1)) }.to raise_error(ArgumentError)
-    expect{ subject.make(good.merge(high: 256)) }.to raise_error(ArgumentError)
-  end
-
-  it "ignores additional keys" do
-    expect{ subject.make(good.merge(foo: "a string")) }.not_to raise_error
-  end
-
-end

data/spec/lib/stellar/transaction_envelope_spec.rb

@@ -1,93 +0,0 @@
-require "spec_helper"
-
-describe Stellar::TransactionEnvelope do
-  let(:sender)  { Stellar::KeyPair.random }
-  let(:receiver){ Stellar::KeyPair.random }
-  let(:transaction) do
-    Stellar::Transaction.payment({
-      account:     sender,
-      destination: receiver,
-      sequence:    1,
-      amount:      [:native, 20000000]
-    })
-  end
-
-  let(:envelope){ transaction.to_envelope(*signers) }
-
-  describe "#signed_correctly?" do
-    subject{ envelope.signed_correctly?(*verifiers) }
-
-    context "when unsigned" do
-      let(:signers)  { [] }
-      let(:verifiers){ [sender] }
-
-      it{ should be_falsey }
-    end
-
-    context "when signed by a single account" do
-      let(:signers)  { [sender] }
-      let(:verifiers){ signers }
-
-      context "and signed correctly" do
-        it{ should be_truthy }
-      end
-
-      context "and the signature is corrupted" do
-        before(:each){ envelope.signatures.first.signature = "\xFF" * 32}
-        it{ should be_falsey }
-      end
-
-      context "and the signature is from a different message" do
-        before(:each){ envelope.signatures = [sender.sign_decorated("hello")]}
-        it{ should be_falsey }
-      end
-
-      context "and the key for the signing account is not provided" do
-        let(:verifiers){ [] }
-        it{ should be_falsey }
-      end
-
-      context "and the key for the signing account is wrong" do
-        let(:verifiers){ [receiver] }
-        it{ should be_falsey }
-      end
-    end
-
-    context "when signed by a multiple accounts" do
-      let(:alternate_signer){ Stellar::KeyPair.random }
-      let(:signers)  { [sender, alternate_signer] }
-      let(:verifiers){ signers }
-
-      context "and all public keys are provided" do
-        it{ should be_truthy }
-      end
-
-      context "and all public keys are provided, with additional unused keys provided" do
-        let(:verifiers){ signers + [Stellar::KeyPair.random] }
-        it{ should be_truthy }
-      end
-
-      context "and not all public keys for the signers are provided" do
-        let(:verifiers){ [alternate_signer] }
-        it{ should be_falsey }
-      end
-
-      context "and one of the signatures is corrupted" do
-        before(:each){ envelope.signatures.last.signature = "\xFF" * 32}
-        it{ should be_falsey }
-      end
-
-      context "and the signature is from a different message" do
-        before(:each){ envelope.signatures = signers.map{|s| s.sign_decorated("hello")}}
-        it{ should be_falsey }
-      end
-    end
-
-  end
-
-  describe "#hash" do
-    let(:signers)  { [sender] }
-    subject{ envelope.hash }
-    it{ should eq(Digest::SHA256.digest envelope.to_xdr)}
-  end
-end