stellar-base 0.19.0 → 0.23.0.rc1

data/spec/lib/stellar/networks_spec.rb

@@ -1,77 +0,0 @@
-require "spec_helper"
-
-describe Stellar, ".default_network=" do
-
-  before(:each){ Stellar.default_network = "foo" }
-  after(:each){ Stellar.default_network = nil }
-
-  it "sets the value returned by current_network " do
-    expect(Stellar.current_network).to eql("foo")
-  end
-
-end
-
-describe Stellar, ".current_network" do
-
-  after(:each){ Stellar.default_network = nil }
-
-  it "returns the public network absent any other configuration" do
-    expect(Stellar.current_network).to eql(Stellar::Networks::TESTNET)
-  end
-
-  it "returns the default network if configured and not within a call to on_network" do
-    Stellar.default_network = "foo"
-    expect(Stellar.current_network).to eql("foo")
-  end
-
-  it "returns the network as specified by on_network, even when a default is set" do
-    Stellar.default_network = "foo"
-
-    Stellar.on_network "bar" do
-      expect(Stellar.current_network).to eql("bar")
-    end
-
-    expect(Stellar.current_network).to eql("foo")
-  end
-end
-
-describe Stellar, ".current_network_id" do
-  it "returns the sha256 of the current_network" do
-    expect(Stellar.current_network_id).to eql(Digest::SHA256.digest(Stellar.current_network))
-  end
-end
-
-describe Stellar, ".on_network" do
-
-  after(:each){ Thread.current["stellar_network_passphrase"] = nil }
-
-
-  it "sets the current_network and a thread local" do
-    Stellar.on_network "bar" do
-      expect(Stellar.current_network).to eql("bar")
-      expect(Thread.current["stellar_network_passphrase"]).to eql("bar")
-    end
-  end
-
-
-  it "nests" do
-    Stellar.on_network "foo" do
-      expect(Stellar.current_network).to eql("foo")
-      Stellar.on_network "bar" do
-        expect(Stellar.current_network).to eql("bar")
-      end
-      expect(Stellar.current_network).to eql("foo")
-    end
-  end
-
-
-  it "resets the network value when an error is raised" do
-    begin
-      Stellar.on_network "foo" do
-        raise "kablow"
-      end
-    rescue
-      expect(Stellar.current_network).to_not eql("foo")
-    end
-  end
-end

data/spec/lib/stellar/operation_spec.rb

@@ -1,71 +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
-
-
-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_result_spec.rb

@@ -1,95 +0,0 @@
-require "spec_helper"
-
-describe Stellar::PathPaymentResult, "#send_amount" do
-
-
-  context "when the result is not successful" do
-    subject{ Stellar::PathPaymentResult.new(:path_payment_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::PathPaymentResult::Success.new(last: simple_success) }
-
-    subject{ Stellar::PathPaymentResult.new(:path_payment_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::PathPaymentResult::Success.new({
-        offers: offers,
-        last:   simple_success,
-      })
-    end
-
-    subject{ Stellar::PathPaymentResult.new(:path_payment_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::PathPaymentResult::Success.new({
-        offers: offers,
-        last:   simple_success,
-      })
-    end
-
-    subject{ Stellar::PathPaymentResult.new(:path_payment_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::PathPaymentResult::Success.new({
-        offers: offers,
-        last:   simple_success,
-      })
-    end
-
-    subject{ Stellar::PathPaymentResult.new(:path_payment_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.new("#{whole}.#{fractional}")
-      actual_p = subject.from_f(expected)
-      actual = BigDecimal.new(actual_p.n) / BigDecimal.new(actual_p.d) 
-
-      expect(actual).to be_within(BigDecimal.new("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