bitcoin 0.1.0 → 0.1.2

data/lib/bitcoin/version.rb

@@ -1,3 +1,3 @@
 module Bitcoin
-  VERSION = "0.1.0"
+  VERSION = "0.1.2"
 end

data/spec/bitcoin/cli_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+require 'bitcoin/cli'
+
+# Dependencies only used in the spec
+require 'bitcoin/console/capturing_stream_bundle'
+
+module Bitcoin
+  describe CLI do
+    let(:stream_bundle) { Console::CapturingStreamBundle.test_bundle }
+    let(:cli) { CLI.new(stream_bundle) }
+
+    describe "help" do
+      shared_examples_for "inputs that trigger a full help message" do
+        let(:help_command) { mock(Commands::HelpCommand, show_help: nil) }
+
+        before(:each) do
+          Commands::HelpCommand.stub(new: help_command)
+        end
+
+        it "creates a Help Command" do
+          Commands::HelpCommand.should_receive(:new).with(stream_bundle)
+          run_command
+        end
+
+        it "shows the full help" do
+          help_command.should_receive(:show_help)
+          run_command
+        end
+
+        it "returns 0", because: "the CLI wrapper exits with this value" do
+          run_command.should eq 0
+        end
+      end
+
+      describe "<no command>" do
+        def run_command
+          cli.run([ ])
+        end
+
+        it_behaves_like "inputs that trigger a full help message"
+      end
+
+      describe "help" do
+        def run_command
+          cli.run(%w[ help ])
+        end
+
+        it_behaves_like "inputs that trigger a full help message"
+      end
+
+      describe "<unknown command>" do
+        let(:help_command) { mock(Commands::HelpCommand, show_unknown_command_help: nil) }
+
+        before(:each) do
+          Commands::HelpCommand.stub(new: help_command)
+        end
+
+        def run_command
+          cli.run(%w[ thiscommanddoesnotexist ])
+        end
+
+        it "creates a Help Command" do
+          Commands::HelpCommand.should_receive(:new).with(stream_bundle)
+          run_command
+        end
+
+        it "shows the unknown command help" do
+          help_command.should_receive(:show_unknown_command_help).with("thiscommanddoesnotexist")
+          run_command
+        end
+
+        it "returns 1", because: "the CLI wrapper exits with this value" do
+          run_command.should eq 1
+        end
+      end
+    end
+
+    describe "satoshi-wallet" do
+      let(:wallet_command) { mock(Commands::SatoshiWalletCommand, run: nil) }
+      let(:satoshi_wallet_command_environment) { mock(Commands::SatoshiWalletCommandEnvironment) }
+
+      before(:each) do
+        Commands::SatoshiWalletCommand.stub(new: wallet_command)
+        Commands::SatoshiWalletCommandEnvironment.stub(new: satoshi_wallet_command_environment)
+      end
+
+      def run_command
+        cli.run(%W[ satoshi-wallet subcommand-name wallet.dat foo bar ])
+      end
+
+      it "creates an environment" do
+        Commands::SatoshiWalletCommandEnvironment.should_receive(:new).with(stream_bundle)
+        run_command
+      end
+
+      it "creates a command" do
+        Commands::SatoshiWalletCommand.should_receive(:new).with(stream_bundle, satoshi_wallet_command_environment)
+        run_command
+      end
+
+      it "runs the command" do
+        wallet_command.should_receive(:run).with(%w[ subcommand-name wallet.dat foo bar ])
+        run_command
+      end
+
+      context "the command succeeds" do
+        before(:each) do
+          wallet_command.stub(run: nil)
+        end
+
+        it "returns 0", because: "the CLI wrapper exits with this value" do
+          run_command.should eq 0
+        end
+      end
+
+      context "the command fails" do
+        before(:each) do
+          wallet_command.stub(:run).and_raise(CLI::CommandError.new)
+        end
+
+        it "returns 1", because: "the CLI wrapper exits with this value" do
+          run_command.should eq 1
+        end
+      end
+    end
+  end
+end

data/spec/bitcoin/commands/help_command_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+require 'bitcoin/commands/help_command'
+require 'bitcoin/console/capturing_stream_bundle'
+
+module Bitcoin
+  module Commands
+    describe HelpCommand do
+      let(:stream_bundle) { Console::CapturingStreamBundle.test_bundle }
+
+      subject { HelpCommand.new(stream_bundle) }
+
+      describe "#show_help" do
+        it "prints the full help" do
+          subject.show_help
+          # Duplicated from the Cucumber feature to get us going
+          stream_bundle.captured_output.should eq(
+            -%{
+              Usage: rbcoin COMMAND ...
+
+              Commands:
+                help            Display help about rbcoin and rbcoin commands
+                satoshi-wallet  Manipulate the wallet.dat file of the original client
+
+              Use "rbcoin COMMAND --help" or "rbcoin help COMMAND" for help on a single command
+              Use "rbcoin --version" to see the rbcoin version number
+              Use "rbcoin --exact-version" to see the all version details (with dependencies)
+            } + "\n"
+          )
+        end
+      end
+
+      describe "#show_unknown_command_help" do
+        it "prints an error message to the output", because: "it's currently not this object that detected the error" do
+          subject.show_unknown_command_help("thiscommanddoesnotexist")
+          # Duplicated from the Cucumber feature
+          stream_bundle.captured_output.should eq(
+            -%{
+              rbcoin failed:  No such command "thiscommanddoesnotexist"
+              Try: `rbcoin help`
+            } + "\n"
+          )
+        end
+
+        it "doesn't raise an error", because: "it's currently not this object that detected the error" do
+          expect {
+            subject.show_unknown_command_help("thiscommanddoesnotexist")
+          }.to_not raise_error
+        end
+      end
+    end
+  end
+end

data/spec/bitcoin/commands/satoshi_wallet/add_address_command_spec.rb

@@ -0,0 +1,149 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+require 'bitcoin/commands/satoshi_wallet/add_address_command'
+
+# Dependencies required only in the spec
+require 'bitcoin/console/capturing_stream_bundle'
+require 'bitcoin/data_access/satoshi/satoshi_wallet'
+
+module Bitcoin
+  module Commands
+    module SatoshiWallet
+      describe AddAddressCommand do
+        let(:stream_bundle) { Console::CapturingStreamBundle.test_bundle }
+        let(:wallet) { mock(DataAccess::Satoshi::SatoshiWallet, add_address: nil) }
+
+        let(:subject) { AddAddressCommand.new(stream_bundle) }
+        
+        context "the input args are valid" do
+          def run_command
+            subject.run(wallet, args: [ "14Z1mazY4HfysZyMaKudFr63EwHqQT2njz", "Bitcoin Monitor" ])
+          end
+
+          it "adds the address" do
+            wallet.should_receive(:add_address).with(
+              Domain::BitcoinAddress.new("14Z1mazY4HfysZyMaKudFr63EwHqQT2njz"),
+              name: "Bitcoin Monitor"
+            )
+            run_command
+          end
+
+          it "informs the user that the address was added" do
+            run_command
+            stream_bundle.captured_output.should eq "Address added successfully\n"
+          end
+        end
+
+        context "the input args are invalid" do
+          context "missing arguments" do
+            invalid_arg_sets = [
+              %w[ ], # Pressed enter too soon
+              %w[ 14Z1mazY4HfysZyMaKudFr63EwHqQT2njz ] # Missing name
+            ]
+
+            invalid_arg_sets.each do |invalid_args|
+              it "prints an error message" do
+                expect {
+                  subject.run(wallet, args: invalid_args)
+                }.to raise_error
+
+                stream_bundle.captured_error.should include("You must provide both a Bitcoin address and a name to add to a wallet")
+                stream_bundle.captured_error.should =~ /No changes were made to the wallet\n\Z/
+              end
+
+              it "raises an error" do
+                expect {
+                  subject.run(wallet, args: invalid_args)
+                }.to raise_error(CLI::CommandError)
+              end
+            end
+          end
+
+          context "too many args" do
+            def run_command
+              subject.run(wallet, args: %w[ 14Z1mazY4HfysZyMaKudFr63EwHqQT2njz foo bar baz ])
+            end
+
+            it "prints a helpful error message" do
+              expect { run_command }.to raise_error
+
+              stream_bundle.captured_error.should include(
+                -%{
+                  Received too many arguments
+
+                  To make sure the name is formatted correctly we ask you to use use quotes
+                  around the name, e.g.: "foo bar baz"
+
+                  No changes were made to the wallet
+                }
+              )
+              stream_bundle.captured_error.should =~ /\n\Z/
+            end
+
+            it "raises an error" do
+              expect { run_command }.to raise_error(CLI::CommandError)
+            end
+          end
+
+          context "invalid Bitcoin address" do
+            def run_command
+              subject.run(wallet, args: [ "Invalid Bitcoin address", "Bitcoin Monitor" ])
+            end
+
+            it "prints an error message" do
+              expect {
+                run_command
+              }.to raise_error
+
+              # Ugh! There's got to be a better way of getting the error message than this,
+              # hopefully without having to stub out the creating of a value object...
+              expected_error =
+                begin
+                  Domain::BitcoinAddress.new("Invalid Bitcoin address")
+                rescue Domain::BitcoinAddress::InvalidBitcoinAddressError => error
+                  error.message
+                end
+
+              stream_bundle.captured_error.should include(error.message)
+              stream_bundle.captured_error.should =~ /The address was not added to the wallet\n\Z/
+            end
+
+            it "raises an error" do
+              expect {
+                run_command
+              }.to raise_error(CLI::CommandError)
+            end
+          end
+
+          # This is paranoid, but currently we don't handle string length properly in the Berkeley DB code
+          # (This error handling is not publically documented)
+          context "excessively long names" do
+            string_253_bytes_long = "#{"☃" * 84}."
+
+            define_method :run_command do
+              subject.run(wallet, args: [ "14Z1mazY4HfysZyMaKudFr63EwHqQT2njz", string_253_bytes_long ])
+            end
+
+            it "prints an error message" do
+              expect {
+                run_command
+              }.to raise_error
+
+              stream_bundle.captured_error.should include(%'The address name "#{string_253_bytes_long}" is too long\n')
+              stream_bundle.captured_error.should include("Currently we do not allow address names over 252 bytes long\n")
+              stream_bundle.captured_error.should =~ /The address was not added to the wallet\n\Z/
+            end
+
+            it "raises an error" do
+              expect {
+                run_command
+              }.to raise_error(CLI::CommandError)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/bitcoin/commands/satoshi_wallet/show_addresses_command_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+require 'bitcoin/commands/satoshi_wallet/show_addresses_command'
+
+# Dependencies required only in the spec
+require 'bitcoin/console/capturing_stream_bundle'
+require 'bitcoin/data_access/satoshi/satoshi_wallet'
+
+module Bitcoin
+  module Commands
+    module SatoshiWallet
+      describe ShowAddressesCommand do
+        let(:stream_bundle) { Console::CapturingStreamBundle.test_bundle }
+        let(:address_book) { mock(Domain::AddressBook, to_s: "addresses") }
+        let(:wallet) { mock(DataAccess::Satoshi::SatoshiWallet, addresses: address_book) }
+
+        let(:subject) { ShowAddressesCommand.new(stream_bundle) }
+
+        it "prints the addresses to the output stream" do
+          subject.run(wallet, wallet_filename: "wallet.dat")
+          stream_bundle.captured_output.should eq "# All addresses in wallet.dat\naddresses\n"
+        end
+      end
+    end
+  end
+end

data/spec/bitcoin/commands/satoshi_wallet/show_version_command_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+require 'bitcoin/commands/satoshi_wallet/show_version_command'
+
+# Dependencies required only in the spec
+require 'bitcoin/console/capturing_stream_bundle'
+require 'bitcoin/data_access/satoshi/satoshi_version'
+require 'bitcoin/data_access/satoshi/satoshi_wallet'
+
+module Bitcoin
+  module Commands
+    module SatoshiWallet
+      describe ShowVersionCommand do
+        let(:stream_bundle) { Console::CapturingStreamBundle.test_bundle }
+        let(:wallet) { mock(DataAccess::Satoshi::SatoshiWallet, version: DataAccess::Satoshi::SatoshiVersion.new(0, 3, 24)) }
+
+        let(:subject) { ShowVersionCommand.new(stream_bundle) }
+
+        it "prints the wallet's version" do
+          subject.run(wallet)
+          stream_bundle.captured_output.should eq "0.3.24\n"
+        end
+      end
+    end
+  end
+end

data/spec/bitcoin/commands/satoshi_wallet_command_environment_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+require 'bitcoin/commands/satoshi_wallet_command_environment'
+
+# Dependencies required only in the spec
+require 'bitcoin/data_access/satoshi/satoshi_wallet'
+require 'bitcoin/console/capturing_stream_bundle'
+
+module Bitcoin
+  module Commands
+    describe SatoshiWalletCommandEnvironment do
+      include FakeFS::SpecHelpers
+
+      let(:empty_temp_dir) { mock(FileSystem::EmptyTempDir, absolute_path: "/path/to/temp/dir") }
+      let(:satoshi_wallet) { mock(DataAccess::Satoshi::SatoshiWallet) }
+
+      before(:each) do
+        FileSystem::EmptyTempDir.stub(:open).and_yield(empty_temp_dir)
+        DataAccess::Satoshi::SatoshiWallet.stub(:open).and_yield(satoshi_wallet)
+      end
+
+      let(:command) { mock(Commands::SatoshiWallet, run: nil) }
+      let(:stream_bundle) { Console::CapturingStreamBundle.test_bundle }
+
+      subject { SatoshiWalletCommandEnvironment.new(stream_bundle) }
+
+      context "the wallet file exists" do
+        before(:each) { File.open("wallet.dat", "w") { |file| file << "unused wallet data" } }
+
+        it "create temp dir" do
+          FileSystem::EmptyTempDir.should_receive(:open).with(with_name: "bitcoinrb_db_tmp", parallel_to: PROJECT_ROOT + "/wallet.dat")
+          subject.run_command(command, %w[ wallet.dat foo bar ])
+        end
+
+        it "opens the wallet" do
+          DataAccess::Satoshi::SatoshiWallet.should_receive(:open).with(
+            wallet_filename: File.join(PROJECT_ROOT, "/wallet.dat"), # because this is the directory the specs run in
+            db_dirname: "/path/to/temp/dir"
+          )
+          subject.run_command(command, %w[ wallet.dat foo bar ])
+        end
+
+        it "runs the command" do
+          command.should_receive(:run).with(satoshi_wallet, wallet_filename: "wallet.dat", args: %w[ foo bar ])
+          subject.run_command(command, %w[ wallet.dat foo bar ])
+        end
+      end
+
+      context "the wallet file does not exist" do
+        it "prints an error" do
+          expect {
+            subject.run_command(command, %w[ missing_wallet.dat foo bar ])
+          }.to raise_error
+
+          stream_bundle.captured_error.should eq "Couldn't find wallet file: missing_wallet.dat\n"
+        end
+
+        it "raises a CLI::CommandError" do
+          expect {
+            subject.run_command(command, %w[ missing_wallet.dat foo bar ])
+          }.to raise_error(CLI::CommandError)
+        end
+
+        it "does not attempt the rest of the code" do
+          # Although this does involve a lot of knowledge about the code, as
+          # it's not immediately obvious why this proves nothing else is run
+          FileSystem::EmptyTempDir.should_not_receive(:open)
+
+          expect {
+            subject.run_command(command, %w[ missing_wallet.dat foo bar ])
+          }.to raise_error
+        end
+      end
+    end
+  end
+end