bitcoin 0.1.2 → 0.2.0

data/spec/bitcoin/console/stream_bundle_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-require 'bitcoin/console/stream_bundle'
-
-require_relative '_contracts/stream_bundle_contract'
-
-module Bitcoin
-  module Console
-    describe StreamBundle do
-      it_satisfies_contract "StreamBundle"
-    end
-  end
-end

data/spec/bitcoin/data_access/satoshi/bdb_satoshi_wallet_repository_spec.rb

@@ -1,78 +0,0 @@
-require 'spec_helper'
-
-require 'bitcoin/data_access/satoshi/bdb_satoshi_wallet_repository'
-require 'bitcoin/rspec/directory_helpers'
-
-module Bitcoin
-  module DataAccess
-    module Satoshi
-      describe BDBSatoshiWalletRepository, adapter: :slow do
-        include Bitcoin::RSpec::DirectoryHelpers
-
-        TEMP_DB_DIR = File.join(PROJECT_ROOT, "tmp", "db").freeze
-        ensure_empty_test_dir(TEMP_DB_DIR)
-
-        # Temporary means to get a copy of the fixture file
-        before(:each) do
-          FileUtils.cp(File.join(PROJECT_ROOT, "features", "fixtures", wallet_fixture_filename), TEMP_DB_DIR)
-        end
-
-        def wallet_filename
-          File.join(PROJECT_ROOT, "tmp", "db", wallet_fixture_filename)
-        end
-
-        let(:wallet_fixture_filename) { "addressbook_wallet.dat" }
-
-        subject { BDBSatoshiWalletRepository.new(wallet_filename, db_dirname: TEMP_DB_DIR) }
-
-        it "has a less naive write_compact_size"
-
-        describe "4-byte unsigned little endian integers stored immediately (no compact length in the value)" do
-          specify {
-            subject.get_value_immediate_uint32le("version").should eq 32400
-          }
-
-          specify {
-            expect {
-              subject.set_value_immediate_uint32le("version", 32500)
-            }.to change {
-              subject.get_value_immediate_uint32le("version")
-            }.from(32400).to(32500)
-          }
-        end
-
-        describe "string key data, string value data" do
-          it "lets you read all values" do
-            subject.get_key_and_value_data_string_utf8("name").should eq [
-              [ "13f2t2WKnCZh1rZbDhdUKB6fY1rZNWZVzd", "Receiving address 2" ],
-              [ "14Z1mazY4HfysZyMaKudFr63EwHqQT2njz", "Bitcoin Monitor" ],
-              [ "16kzGRdP8LToECecna3EynghiApUM9duLw", "Receiving address 1" ],
-              [ "1Nqr3MqVyUp6k3o3QPePAdn4Yg4tzgB9kw", "Bitcoincharts" ]
-            ]
-          end
-
-          it "lets you read individual values" do
-            subject.get_value_with_key_data_string_utf8("name", "14Z1mazY4HfysZyMaKudFr63EwHqQT2njz").should eq "Bitcoin Monitor"
-          end
-
-          it "lets you create" do
-            expect {
-              subject.set_value_with_key_data_string_utf8("name", "1ThisIsAMadeUpKeyKudFr63EwHqQT2njz", "New Value")
-            }.to change {
-              subject.get_value_with_key_data_string_utf8("name", "1ThisIsAMadeUpKeyKudFr63EwHqQT2njz")
-            }.from(nil).to("New Value")
-          end
-
-          it "lets you update" do
-            expect {
-              subject.set_value_with_key_data_string_utf8("name", "14Z1mazY4HfysZyMaKudFr63EwHqQT2njz", "Really is Bitcoin Monitor")
-            }.to change {
-              subject.get_value_with_key_data_string_utf8("name", "14Z1mazY4HfysZyMaKudFr63EwHqQT2njz")
-            }.from("Bitcoin Monitor").to("Really is Bitcoin Monitor")
-          end
-        end
-      end
-    end
-  end
-end
-

data/spec/bitcoin/data_access/satoshi/satoshi_version_spec.rb

@@ -1,112 +0,0 @@
-require 'spec_helper'
-
-require 'bitcoin/data_access/satoshi/satoshi_version'
-
-module Bitcoin
-  module DataAccess
-    module Satoshi
-      describe SatoshiVersion do
-        describe ".from_wallet_bytes" do
-          it "supports the data format as extracted from the BDB database" do
-            SatoshiVersion.from_wallet_bytes([144, 126, 0, 0]).should eq SatoshiVersion.new(0, 3, 24)
-          end
-        end
-
-        describe ".from_wallet_int" do
-          it "supports the data format as extracted from the BDB database" do
-            SatoshiVersion.from_wallet_int(32400).should eq SatoshiVersion.new(0, 3, 24)
-          end
-        end
-
-        describe "three-part form" do
-          it "compares equality" do
-            SatoshiVersion.new(0, 3, 24).should eq SatoshiVersion.new(0, 3, 24)
-
-            SatoshiVersion.new(0, 3, 24).should_not eq SatoshiVersion.new(0, 3, 25)
-            SatoshiVersion.new(0, 3, 24).should_not eq SatoshiVersion.new(0, 4, 24)
-            SatoshiVersion.new(0, 3, 24).should_not eq SatoshiVersion.new(1, 3, 24)
-          end
-
-          it "has a total ordering" do
-            SatoshiVersion.new(0, 3, 24).should be < SatoshiVersion.new(0, 3, 25)
-            SatoshiVersion.new(0, 3, 24).should be > SatoshiVersion.new(0, 3, 23)
-
-            SatoshiVersion.new(0, 3, 24).should be < SatoshiVersion.new(0, 4, 23)
-            SatoshiVersion.new(0, 3, 24).should be > SatoshiVersion.new(0, 2, 25)
-
-            SatoshiVersion.new(1, 3, 24).should be < SatoshiVersion.new(2, 2, 23)
-            SatoshiVersion.new(1, 3, 24).should be > SatoshiVersion.new(0, 4, 25)
-          end
-        end
-
-        describe "four-part form" do
-          # We cheat slightly here and make assumptions about the implementation
-          # (by not re-specifying every conceivable possibility)
-
-          it "compares equality" do
-            SatoshiVersion.new(0, 3, 24, 0).should eq SatoshiVersion.new(0, 3, 24, 0)
-            SatoshiVersion.new(0, 3, 24, 0).should_not eq SatoshiVersion.new(0, 3, 24, 1)
-          end
-
-          it "has a total ordering" do
-            SatoshiVersion.new(0, 3, 24, 1).should be < SatoshiVersion.new(0, 3, 25, 2)
-            SatoshiVersion.new(0, 3, 24, 1).should be > SatoshiVersion.new(0, 3, 23, 0)
-
-            SatoshiVersion.new(0, 3, 24, 1).should be < SatoshiVersion.new(0, 3, 25, 0)
-            SatoshiVersion.new(0, 3, 24, 1).should be > SatoshiVersion.new(0, 3, 23, 2)
-
-            # etc, for the rest of the components...
-          end
-        end
-
-        describe "-beta version suffixes" do
-          it "are not supported", because: "this is hardcoded into the Satoshi client" do
-            # As of 0.3.24, the "beta" status is determined in the C++ code with this value:
-            # static const bool VERSION_IS_BETA = true;
-            false.should be_false
-          end
-        end
-
-        describe "comparing three- and four-part forms" do
-          # This is not explicit in the Satoshi code, but seems a reasonable assumption for now,
-          # until it breaks...
-          it "assumes an implicit 0 at the end of the three-part form" do
-            SatoshiVersion.new(0, 3, 24).should eq SatoshiVersion.new(0, 3, 24, 0)
-            SatoshiVersion.new(0, 3, 24, 0).should eq SatoshiVersion.new(0, 3, 24)
-            # it seems safe to assume the rest of the comparisons work by induction
-          end
-        end
-
-        describe "conversion" do
-          describe "to strings" do
-            it "supports #to_s", because: "we need to be usable with IO#<<" do
-              SatoshiVersion.new(0, 3, 24).to_s.should eq "0.3.24"
-              SatoshiVersion.new(0, 3, 24, 1).to_s.should eq "0.3.24.1"
-            end
-
-            it "truncates a fourth zero", because: "the standard client does this (semantic versioning?)" do
-              SatoshiVersion.new(0, 3, 24, 0).to_s.should eq "0.3.24"
-            end
-
-            it "does not truncate a third version", because: "the standard client does this (semantic versioning?)" do
-              SatoshiVersion.new(0, 4, 0).to_s.should eq "0.4.0"
-            end
-
-            it "supports #to_str as an alias of :to_s" do
-              version = SatoshiVersion.new(0, 3, 24)
-              to_s_method = version.method(:to_s)
-              to_str_method = version.method(:to_str)
-              to_str_method.should eq to_s_method
-            end
-          end
-
-          describe "to Satoshi-format wallet bytes" do
-            it "creates the same bytes as came from the BDB database" do
-              SatoshiVersion.new(0, 3, 24).to_wallet_bytes.should eq [144, 126, 0, 0]
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/bitcoin/data_access/satoshi/satoshi_wallet_spec.rb

@@ -1,102 +0,0 @@
-require 'spec_helper'
-
-require 'bitcoin/data_access/satoshi/satoshi_wallet'
-
-module Bitcoin
-  module DataAccess
-    module Satoshi
-      describe SatoshiWallet do
-        describe ".open" do
-          let(:satoshi_wallet_repository) { mock(BDBSatoshiWalletRepository) }
-          let(:satoshi_wallet) { mock(SatoshiWallet) }
-
-          before(:each) do
-            BDBSatoshiWalletRepository.stub(new: satoshi_wallet_repository)
-            SatoshiWallet.stub(new: satoshi_wallet)
-          end
-
-          it "makes a BDBSatoshiWalletRepository" do
-            BDBSatoshiWalletRepository.should_receive(:new).with("wallet.dat", db_dirname: "/db/dir")
-            SatoshiWallet.open(wallet_filename: "wallet.dat", db_dirname: "/db/dir", & ->(wallet) { :noop })
-          end
-
-          it "makes a SatoshiWallet with the BDBSatoshiWalletRepository" do
-            SatoshiWallet.should_receive(:new).with(satoshi_wallet_repository)
-            SatoshiWallet.open(wallet_filename: "wallet.dat", db_dirname: "/db/dir", & ->(wallet) { :noop })
-          end
-
-          it "yields the wallet" do
-            SatoshiWallet.open(wallet_filename: "wallet.dat", db_dirname: "/db/dir") do |wallet|
-              wallet.should eq satoshi_wallet
-            end
-          end
-
-          it "returns the value of the block" do
-            SatoshiWallet.open(wallet_filename: "wallet.dat", db_dirname: "/db/dir") { |wallet|
-              :block_value
-            }.should eq :block_value
-          end
-
-          it "raises an error if no block is given", because: "we use blocks to manage the opening and closing of the BDB database" do
-            expect {
-              SatoshiWallet.open(wallet_filename: "wallet.dat", db_dirname: "/db/dir")
-            }.to raise_error(ArgumentError) { |error|
-              error.message.should =~ /you must provide a block to SatoshiWallet\.new/i
-            }
-          end
-        end
-
-        describe "instance methods" do
-          let(:satoshi_wallet_repository) { mock(BDBSatoshiWalletRepository) }
-
-          before(:each) do
-            BDBSatoshiWalletRepository.stub(new: satoshi_wallet_repository)
-          end
-
-          subject { SatoshiWallet.new(satoshi_wallet_repository) }
-
-          describe "#version" do
-            it "returns the version from the wallet" do
-              satoshi_wallet_repository.should_receive(:get_value_immediate_uint32le).with("version").and_return(32400)
-              subject.version.should eq SatoshiVersion.new(0, 3, 24)
-            end
-          end
-
-          describe "#addresses" do
-            before(:each) do
-              satoshi_wallet_repository.stub(
-                get_key_and_value_data_string_utf8: [
-                  [ "14Z1mazY4HfysZyMaKudFr63EwHqQT2njz", "Bitcoin Monitor" ],
-                  [ "1Nqr3MqVyUp6k3o3QPePAdn4Yg4tzgB9kw", "Bitcoincharts" ]
-                ]
-              )
-            end
-
-            it "fetches the data" do
-              satoshi_wallet_repository.should_receive(:get_key_and_value_data_string_utf8).with("name")
-              subject.addresses
-            end
-
-            it "returns an AddressBook with the wallet addresses" do
-              subject.addresses.should be_a Domain::AddressBook
-              expected_addresses = Domain::AddressBook.new([
-                { address: Domain::BitcoinAddress.new("14Z1mazY4HfysZyMaKudFr63EwHqQT2njz"), name: "Bitcoin Monitor" },
-                { address: Domain::BitcoinAddress.new("1Nqr3MqVyUp6k3o3QPePAdn4Yg4tzgB9kw"), name: "Bitcoincharts" }
-              ]).to_a
-              subject.addresses.to_a.should =~ expected_addresses
-            end
-          end
-
-          describe "#add_address" do
-            it "adds the BitcoinAddress to the Wallet" do
-              satoshi_wallet_repository.should_receive(:set_value_with_key_data_string_utf8).with(
-                "name", "14Z1mazY4HfysZyMaKudFr63EwHqQT2njz", "Bitcoin Monitor"
-              )
-              subject.add_address(Domain::BitcoinAddress.new("14Z1mazY4HfysZyMaKudFr63EwHqQT2njz"), name: "Bitcoin Monitor")
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/bitcoin/domain/address_book_spec.rb

@@ -1,63 +0,0 @@
-require 'spec_helper'
-
-require 'bitcoin/domain/address_book'
-
-module Bitcoin
-  module Domain
-    describe AddressBook do
-      context "made with no addresses" do
-        subject { AddressBook.new }
-        its(:to_a) { should eq [ ] }
-      end
-
-      context "made with addresses" do
-        let(:address_hashes) {
-          [
-            { address: "14Z1mazY4HfysZyMaKudFr63EwHqQT2njz", name: "Bitcoin Monitor" },
-            { address: "1Nqr3MqVyUp6k3o3QPePAdn4Yg4tzgB9kw", name: "Bitcoincharts" }
-          ]
-        }
-
-        subject {
-          AddressBook.new(address_hashes)
-        }
-
-        its(:to_a) {
-          should =~ [
-            { address: "14Z1mazY4HfysZyMaKudFr63EwHqQT2njz", name: "Bitcoin Monitor" },
-            { address: "1Nqr3MqVyUp6k3o3QPePAdn4Yg4tzgB9kw", name: "Bitcoincharts" }
-          ]
-        }
-
-        # We're assuming the output comes out in the input order, so this example is
-        # overly precise until we know how we'll handle presentation
-        its(:to_s) {
-          should eq(
-            -%{
-              14Z1mazY4HfysZyMaKudFr63EwHqQT2njz Bitcoin Monitor
-              1Nqr3MqVyUp6k3o3QPePAdn4Yg4tzgB9kw Bitcoincharts
-            }
-          )
-        }
-
-        describe "argument cloning" do
-          # Ensure this is created before we try changing the input arguments
-          before(:each) { subject }
-
-          it "does not mutate the args" do
-            expect {
-              address_hashes.delete_if { true }
-            }.to_not change {
-              subject.to_a.length
-            }.from(2).to(0)
-          end
-
-          it "makes a deep copy" do
-            address_hashes.first[:name] = "changed"
-            subject.to_a.map { |hash| hash[:name] }.should_not include("changed")
-          end
-        end
-      end
-    end
-  end
-end

data/spec/bitcoin/domain/bitcoin_address_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-require 'bitcoin/domain/bitcoin_address'
-
-module Bitcoin
-  module Domain
-    describe BitcoinAddress do
-      context "created with a valid real network address" do
-        subject { BitcoinAddress.new("14Z1mazY4HfysZyMaKudFr63EwHqQT2njz") }
-
-        its(:to_s) { should eq "14Z1mazY4HfysZyMaKudFr63EwHqQT2njz" }
-
-        describe "#==" do
-          it "is equal to another BitcoinAddress with the same address" do
-            subject.should eq BitcoinAddress.new("14Z1mazY4HfysZyMaKudFr63EwHqQT2njz")
-          end
-
-          it "is not equal to a BitcoinAddress with a different address" do
-            subject.should_not eq BitcoinAddress.new("1Nqr3MqVyUp6k3o3QPePAdn4Yg4tzgB9kw")
-          end
-
-          it "is not equal to a String" do
-            subject.should_not eq "14Z1mazY4HfysZyMaKudFr63EwHqQT2njz"
-          end
-        end
-      end
-
-      context "creating with an invalid address" do
-        invalid_addresses = [
-          # Not actually sure the reasons here are valid in general but it's just enough to
-          # get us going (the point of the exercise is to put an error protocol in place)
-          { address: "14Z1mazY4HfysZyMaKudFr63EwHqQT2nj",   because: "this is too short" },
-          { address: "14Z1mazY4HfysZyMaKudFr63EwHqQT2njzX", because: "this is too long" }
-          # Hash doesn't match
-          # Wrong version
-          # ... etc ...
-          # (When we know more about Bitcoin crypto we can come back and finish this off)
-        ]
-
-        invalid_addresses.each do |invalid_address|
-          it "raises an error for address #{invalid_address[:address]} because #{invalid_address[:because]}" do
-            expect {
-              BitcoinAddress.new(invalid_address[:address])
-            }.to raise_error(BitcoinAddress::InvalidBitcoinAddressError) { |error|
-              error.message.should eq %'The address "#{invalid_address[:address]}" is not a valid Bitcoin address'
-            }
-          end
-        end
-      end
-    end
-  end
-end

data/spec/bitcoin/filesystem/empty_temp_dir_spec.rb

@@ -1,170 +0,0 @@
-require 'spec_helper'
-
-require 'bitcoin/filesystem/empty_temp_dir'
-require 'bitcoin/rspec/directory_helpers'
-
-module Bitcoin
-  module FileSystem
-    describe EmptyTempDir do
-      include Bitcoin::RSpec::DirectoryHelpers
-
-      TEMP_TEST_DIR = File.join(PROJECT_ROOT, "tmp", "test").freeze
-
-      ensure_empty_test_dir(TEMP_TEST_DIR)
-
-      describe ".open" do
-        describe "integration" do # refactoring invariant
-          it "lets you create a temporary file inside the temporary directory" do
-            expected_temp_dir_name = File.join(TEMP_TEST_DIR, "temp_dir")
-
-            EmptyTempDir.open(with_name: "temp_dir", parallel_to: File.join(TEMP_TEST_DIR, "wallet.dat")) do |temp_dir|
-              File.open(File.join(temp_dir.absolute_path, "test_file"), "w") do |file|
-                file << "some unimportant contents"
-              end
-              Dir.entries(temp_dir.absolute_path).should eq %w[ . .. test_file ]
-            end
-
-            File.exist?(expected_temp_dir_name).should be_false
-          end
-        end
-
-        describe "interactions" do
-          let(:block_runner) { mock(EmptyTempDir::BlockRunner, run: :block_runner_run_value) }
-
-          before(:each) do
-            EmptyTempDir::BlockRunner.stub(new: block_runner)
-          end
-
-          it "raises an error if no block is provided", because: "this would be a pointless thing to do" do
-            expect {
-              EmptyTempDir.open(with_name: "temp_dir", parallel_to: File.join(TEMP_TEST_DIR, "wallet.dat"))
-            }.to raise_error(ArgumentError) { |error|
-              error.message.should =~ /you must provide a block to EmptyTempDir\.open/i
-            }
-          end
-
-          describe "creating the BlockRunner" do
-            it "calculates a directory name parallel to the file" do
-              EmptyTempDir::BlockRunner.should_receive(:new).with("/foo/bar/temp_dir")
-              EmptyTempDir.open(with_name: "temp_dir", parallel_to: "/foo/bar/baz", & -> { :noop })
-            end
-
-            it "always passed absolute directories" do
-              EmptyTempDir::BlockRunner.should_receive(:new).with(File.join(PROJECT_ROOT, "/foo/bar/anything"))
-              EmptyTempDir.open(with_name: "anything", parallel_to: "foo/bar/baz", & -> { :noop })
-            end
-          end
-
-          it "runs the block" do
-            block = -> { :block_value }
-            block_runner.should_receive(:run).with(block_evaluating_to(:block_value))
-            EmptyTempDir.open(with_name: "anything", parallel_to: "/foo/bar/baz", &block)
-          end
-
-          it "returns the value of the block" do
-            EmptyTempDir.open(with_name: "temp_dir", parallel_to: "/foo/bar/baz", & -> { :noop }).should eq :block_runner_run_value
-          end
-        end
-      end
-
-      describe EmptyTempDir::BlockRunner do
-        describe ".new" do
-          # Yes, I actually did this to myself.
-          describe "raising an error on unsafe paths", because: "otherwise it could format your hard drive!" do
-            [ "", "/", "//" ].each do |unacceptable_path|
-              it "blocks #{unacceptable_path.inspect}" do
-                expect {
-                  EmptyTempDir::BlockRunner.new(unacceptable_path)
-                }.to raise_error(ArgumentError) { |error|
-                  error.message.should eq "Unacceptable directory name for EmptyTempDir"
-                }
-              end
-            end
-          end
-        end
-
-        describe "#run" do
-          shared_examples "EmptyTempDir::BlockRunner#run" do
-            let(:expected_temp_dir_name) { File.join(TEMP_TEST_DIR, "temp_dir") }
-            subject { EmptyTempDir::BlockRunner.new(expected_temp_dir_name) }
-
-            it "ensures the directory exists" do
-              subject.run(
-                ->(temp_dir) { File.directory?(expected_temp_dir_name) }
-              ).should be_true
-            end
-
-            it "ensures the directory is empty" do
-              subject.run(
-                ->(temp_dir) { Dir.entries(expected_temp_dir_name) }
-              ).should =~ %w[ . .. ]
-            end
-
-            it "removes the directory at the end (even if a file was created inside it)" do
-              subject.run(
-                ->(temp_dir) {
-                  File.open(File.join(temp_dir.absolute_path, "test_file"), "w") do |file|
-                    file << "unimportant contents"
-                  end
-                  Dir.entries(temp_dir.absolute_path).should eq %w[ . .. test_file ]
-                }
-              )
-
-              File.exist?(expected_temp_dir_name).should be_false
-            end
-
-            it "removes the directory even if the block raises an error" do
-              expect {
-                subject.run(->(temp_dir) { raise RuntimeError.new("I'm trying to make the temp dir persist!") })
-              }.to raise_error
-
-              File.exist?(expected_temp_dir_name).should be_false
-            end
-
-            it "re-raises any error thrown in the block" do
-              expected_error = RuntimeError.new("I'm trying to make the temp dir persist!")
-
-              expect {
-                subject.run(->(temp_dir) { raise expected_error })
-              }.to raise_error { |actual_error|
-                actual_error.should equal expected_error
-              }
-            end
-
-            it "has the expected path name" do
-              subject.run(->(temp_dir) { temp_dir.absolute_path.should eq expected_temp_dir_name })
-            end
-
-            it "returns the value of the block", because: "all the examples rely on this" do
-              subject.run(->(temp_dir) {
-                :block_value
-              }).should eq :block_value
-            end
-          end
-
-          context "where the target directory does not exist" do
-            before(:each) do
-              FileUtils.rm_rf(expected_temp_dir_name)
-            end
-
-            it_behaves_like "EmptyTempDir::BlockRunner#run"
-          end
-
-          context "where the target directory exists" do
-            before(:each) do
-              existing_file_name = File.join(expected_temp_dir_name, "intermediate_dir", "test_file")
-
-              # Make the target directory and a file inside a nested folder inside it
-              FileUtils.mkdir_p(File.dirname(existing_file_name))
-              File.open(existing_file_name, "w") do |file|
-                file << "some unimportant contents"
-              end
-            end
-
-            it_behaves_like "EmptyTempDir::BlockRunner#run"
-          end
-        end
-      end
-    end
-  end
-end