dropzone_ruby 0.1

data/spec/config.yml

@@ -0,0 +1,5 @@
+database:
+  adapter: sqlite3
+  database: db/test.sqlite3
+  pool: 5
+  timeout: 5000

data/spec/invoice_spec.rb

@@ -0,0 +1,129 @@
+#encoding: utf-8
+require_relative 'spec_helper'
+require_relative 'sham/invoice'
+require_relative 'sham/payment'
+
+describe Dropzone::Invoice do
+  include_context 'globals'
+
+  describe "defaults" do
+    it "has accessors" do
+      invoice = Dropzone::Invoice.sham!(:build)
+
+      expect(invoice.expiration_in).to eq(6)
+      expect(invoice.amount_due).to eq(100_000_000)
+      expect(invoice.receiver_addr).to eq(test_pubkey)
+    end
+  end
+
+  describe "serialization" do 
+    it "serializes to_transaction" do
+      expect(Dropzone::Invoice.sham!(:build).to_transaction).to eq({
+        tip: 20000, receiver_addr: test_pubkey, 
+        data: "INCRTE\x01p\xFE\x00\xE1\xF5\x05\x01e\x06".force_encoding('ASCII-8BIT') })
+    end
+  end
+
+  describe "database" do
+    after{ clear_blockchain! }
+
+    it ".save() and .find()" do
+      invoice_id = Dropzone::Invoice.sham!(:build).save!(test_privkey)
+      expect(invoice_id).to be_kind_of(String)
+      
+      invoice = Dropzone::Invoice.find invoice_id
+
+      expect(invoice.expiration_in).to eq(6)
+      expect(invoice.amount_due).to eq(100_000_000)
+      expect(invoice.receiver_addr).to eq(test_pubkey)
+    end
+  end
+
+  describe "associations" do
+    # It's a bit obtuse that there can be support for multiple payments
+    # but this should nonetheless be support to aid with reputation analysis
+    it "has_many payments" do 
+      invoice_id = Dropzone::Invoice.sham!(:build, 
+        receiver_addr: TESTER2_PUBLIC_KEY).save!(test_privkey)
+
+      Dropzone::Payment.sham!(:build, invoice_txid: invoice_id,
+        description: 'abc', receiver_addr: test_pubkey ).save! TESTER2_PRIVATE_KEY
+
+      increment_block_height!
+
+      Dropzone::Payment.sham!(:build, invoice_txid: invoice_id, 
+        description: 'xyz', receiver_addr: test_pubkey ).save! TESTER2_PRIVATE_KEY
+
+      invoice = Dropzone::Invoice.find invoice_id
+      expect(invoice.payments.length).to eq(2)
+      expect(invoice.payments.collect(&:description)).to eq(['xyz','abc'])
+    end
+  end
+
+  describe "validations" do 
+    it "validates default build" do
+      expect(Dropzone::Invoice.sham!(:build).valid?).to eq(true)
+    end
+
+    it "validates minimal invoice" do
+      invoice = Dropzone::Invoice.new receiver_addr: test_pubkey
+
+      expect(invoice.valid?).to eq(true)
+    end
+
+    it "expiration_in must be numeric" do
+      invoice = Dropzone::Invoice.sham! expiration_in: 'abc'
+
+      expect(invoice.valid?).to eq(false)
+      expect(invoice.errors.count).to eq(2)
+      expect(invoice.errors.on(:expiration_in)).to eq(
+        ['is not a number', "must be greater than or equal to 0"])
+    end
+
+    it "expiration_in must be gt 0" do
+      invoice = Dropzone::Invoice.sham! expiration_in: -1
+
+      expect(invoice.valid?).to eq(false)
+      expect(invoice.errors.count).to eq(1)
+      expect(invoice.errors.on(:expiration_in)).to eq(
+        ['must be greater than or equal to 0'])
+    end
+
+    it "amount_due must be numeric" do
+      invoice = Dropzone::Invoice.sham! amount_due: 'abc'
+
+      expect(invoice.valid?).to eq(false)
+      expect(invoice.errors.count).to eq(2)
+      expect(invoice.errors.on(:amount_due)).to eq(
+        ['is not a number', "must be greater than or equal to 0"])
+    end
+
+    it "amount_due must be gt 0" do
+      invoice = Dropzone::Invoice.sham! amount_due: -1
+
+      expect(invoice.valid?).to eq(false)
+      expect(invoice.errors.count).to eq(1)
+      expect(invoice.errors.on(:amount_due)).to eq(
+        ['must be greater than or equal to 0'])
+    end
+
+    it "validates output address must be present" do
+      invoice = Dropzone::Invoice.sham! receiver_addr: nil
+
+      expect(invoice.valid?).to eq(false)
+      expect(invoice.errors.count).to eq(1)
+      expect(invoice.errors.on(:receiver_addr)).to eq(['is not present'])
+    end
+
+    it "declaration must not be addressed to self" do
+      id = Dropzone::Invoice.sham!(receiver_addr: test_pubkey).save! test_privkey
+
+      invoice = Dropzone::Invoice.find id
+
+      expect(invoice.valid?).to eq(false)
+      expect(invoice.errors.count).to eq(1)
+      expect(invoice.errors.on(:receiver_addr)).to eq(['matches sender_addr'])
+    end
+
+  end
+end

data/spec/item_spec.rb

@@ -0,0 +1,294 @@
+#encoding: utf-8
+require_relative 'spec_helper'
+require_relative 'sham/item'
+
+describe Dropzone::Item do
+  include_context 'globals'
+
+  describe "defaults" do
+    it "has accessors" do
+      item = Dropzone::Item.sham!(:build)
+
+      expect(item.description).to eq("Item Description")
+      expect(item.price_currency).to eq('BTC')
+      expect(item.price_in_units).to eq(100_000_000)
+      expect(item.expiration_in).to eq(6)
+      expect(item.latitude).to eq(51.500782)
+      expect(item.longitude).to eq(-0.124669)
+      expect(item.radius).to eq(1000)
+      expect(item.receiver_addr).to eq('mfZ1415XX782179875331XX1XXXXXgtzWu')
+      expect(Bitcoin.valid_address?(item.receiver_addr)).to be_truthy
+      expect(item.sender_addr).to eq(nil)
+    end
+  end
+
+  describe "burn addresses" do 
+    it "supports 6 digit distances" do
+      [90, 0, -90, 51.500782,-51.500782].each do |lat|
+        [180, 0, -180, -0.124669,0.124669].each do |lon|
+          [9,8,5,2,0,101,11010,999999,100000].each do |radius|
+            addr = Dropzone::Item.sham!(:build, :radius => radius, 
+              :latitude => lat, :longitude => lon).receiver_addr
+
+            /\AmfZ([0-9X]{9})([0-9X]{9})([0-9X]{6})/.match addr
+
+            expect(addr.length).to eq(34)
+            expect($1.tr('X','0').to_i).to eq(((lat+90) * 1_000_000).floor)
+            expect($2.tr('X','0').to_i).to eq(((lon+180) * 1_000_000).floor)
+            expect($3.tr('X','0').to_i).to eq(radius)
+            
+          end
+        end
+      end
+
+    end
+  end
+
+  describe "serialization" do 
+    it "serializes to_transaction" do
+      expect(Dropzone::Item.sham!(:build).to_transaction).to eq({ tip: 20000,
+        receiver_addr: "mfZ1415XX782179875331XX1XXXXXgtzWu", 
+        data: "ITCRTE\x01d\x10Item Description\x01c\x03BTC\x01p\xFE\x00\xE1\xF5\x05\x01e\x06".force_encoding('ASCII-8BIT') })
+    end
+  end
+
+  describe "database" do
+    after{ clear_blockchain! }
+
+    it ".save() and .find()" do
+      item_id = Dropzone::Item.sham!(:build).save!(test_privkey)
+
+      expect(item_id).to be_kind_of(String)
+
+      item = Dropzone::Item.find(item_id)
+
+      expect(item.description).to eq("Item Description")
+      expect(item.price_currency).to eq('BTC')
+      expect(item.price_in_units).to eq(100_000_000)
+      expect(item.expiration_in).to eq(6)
+      expect(item.latitude).to eq(51.500782)
+      expect(item.longitude).to eq(-0.124669)
+      expect(item.radius).to eq(1000)
+      expect(item.receiver_addr).to eq('mfZ1415XX782179875331XX1XXXXXgtzWu')
+      expect(Bitcoin.valid_address?(item.receiver_addr)).to be_truthy
+      expect(item.sender_addr).to eq(test_pubkey)
+    end
+
+    it "updates must be addressed to self" do
+      item_id = Dropzone::Item.sham!(:build).save!(test_privkey)
+
+      update_id = Dropzone::Item.new(create_txid: item_id,
+        description: 'xyz').save! test_privkey
+
+      update_item = Dropzone::Item.find update_id
+
+      expect(update_item.description).to eq("xyz")
+      expect(update_item.message_type).to eq('ITUPDT')
+      expect(update_item.sender_addr).to eq(test_pubkey)
+      expect(update_item.receiver_addr).to eq(test_pubkey)
+    end
+  end
+
+  describe "validations" do 
+    it "validates default build" do
+      expect(Dropzone::Item.sham!(:build).valid?).to eq(true)
+    end
+
+    it "validates minimal item" do
+      minimal_item = Dropzone::Item.new radius: 1, latitude: 51.500782, 
+        longitude: -0.124669
+
+      expect(minimal_item.valid?).to eq(true)
+    end
+
+    it "requires output address" do
+      no_address = Dropzone::Item.sham! latitude: nil, longitude: nil, radius: nil
+
+      expect(no_address.valid?).to eq(false)
+      expect(no_address.errors.count).to eq(4)
+      expect(no_address.errors.on(:receiver_addr)).to eq(['is not present'])
+    end
+
+    it "requires latitude" do
+      item = Dropzone::Item.sham! latitude: nil
+
+      expect(item.valid?).to eq(false)
+      expect(item.errors.count).to eq(2)
+      expect(item.errors.on(:latitude)).to eq(['is not a number'])
+    end
+
+    it "requires latitude is gte -90" do
+      item = Dropzone::Item.sham! latitude: -90.000001
+
+      expect(item.valid?).to eq(false)
+      expect(item.errors.count).to eq(1)
+      expect(item.errors.on(:latitude)).to eq(['must be greater than or equal to -90'])
+    end
+
+    it "requires latitude is lte 90" do
+      item = Dropzone::Item.sham! latitude: 90.000001
+
+      expect(item.valid?).to eq(false)
+      expect(item.errors.count).to eq(1)
+      expect(item.errors.on(:latitude)).to eq(['must be less than or equal to 90'])
+    end
+
+    it "requires longitude" do
+      item = Dropzone::Item.sham! longitude: nil
+
+      expect(item.valid?).to eq(false)
+      expect(item.errors.count).to eq(2)
+      expect(item.errors.on(:longitude)).to eq(['is not a number'])
+    end
+
+    it "requires longitude is gte -180" do
+      item = Dropzone::Item.sham! longitude: -180.000001
+
+      expect(item.valid?).to eq(false)
+      expect(item.errors.count).to eq(1)
+      expect(item.errors.on(:longitude)).to eq(['must be greater than or equal to -180'])
+    end
+
+    it "requires longitude is lte 180" do
+      item = Dropzone::Item.sham! longitude: 180.000001
+
+      expect(item.valid?).to eq(false)
+      expect(item.errors.count).to eq(1)
+      expect(item.errors.on(:longitude)).to eq(['must be less than or equal to 180'])
+    end
+
+    it "requires radius" do
+      item = Dropzone::Item.sham! radius: nil
+
+      expect(item.valid?).to eq(false)
+      expect(item.errors.count).to eq(2)
+      expect(item.errors.on(:radius)).to eq(['is not a number'])
+    end
+
+    it "requires radius is gte 0" do
+      item = Dropzone::Item.sham! radius: -1
+
+      expect(item.valid?).to eq(false)
+      expect(item.errors.count).to eq(1)
+      expect(item.errors.on(:radius)).to eq(['must be greater than or equal to 0'])
+    end
+
+    it "requires radius is lt 1000000" do
+      item = Dropzone::Item.sham! radius: 1000000
+
+      expect(item.valid?).to eq(false)
+      expect(item.errors.count).to eq(1)
+      expect(item.errors.on(:radius)).to eq(['must be less than 1000000'])
+    end
+
+    it "requires message_type" do
+      item = Dropzone::Item.sham! message_type: 'INVALD'
+
+      expect(item.valid?).to eq(false)
+      expect(item.errors.count).to eq(1)
+      expect(item.errors.on(:message_type)).to eq(['is not valid'])
+    end
+
+    it "descriptions must be text" do
+      item = Dropzone::Item.sham! description: 5
+
+      expect(item.valid?).to eq(false)
+      expect(item.errors.count).to eq(1)
+      expect(item.errors.on(:description)).to eq(['is not a string'])
+    end
+
+    it "price_in_units must be numeric" do
+      item = Dropzone::Item.sham! price_in_units: 'abc', 
+        price_currency: 'USD'
+
+      expect(item.valid?).to eq(false)
+      expect(item.errors.count).to eq(2)
+      expect(item.errors.on(:price_in_units)).to eq(['is not a number',
+        "must be greater than or equal to 0"])
+    end
+
+    it "expiration_in must be numeric" do
+      item = Dropzone::Item.sham! expiration_in: 'abc'
+
+      expect(item.valid?).to eq(false)
+      expect(item.errors.count).to eq(2)
+      expect(item.errors.on(:expiration_in)).to eq(['is not a number',
+        "must be greater than or equal to 0"])
+    end
+
+    it "price_currency must be present if price is present" do
+      item = Dropzone::Item.sham! price_in_units: 100, price_currency: nil
+
+      expect(item.valid?).to eq(false)
+      expect(item.errors.count).to eq(1)
+      expect(item.errors.on(:price_currency)).to eq(['is required if price is specified'])
+    end
+
+  end
+
+  describe "distance calculations" do 
+    it "calculates distance in meters between two points" do 
+       # New York to London:
+       nyc_to_london = Dropzone::Item.distance_between 40.712784, -74.005941, 
+         51.507351, -0.127758
+       texas = Dropzone::Item.distance_between 31.428663, -99.096680, 
+         36.279707, -102.568359
+       hong_kong = Dropzone::Item.distance_between 22.396428, 114.109497,
+        22.408489, 113.906937
+
+       expect(nyc_to_london.round).to eq(5570224)
+       expect(texas.round).to eq(627363)
+       expect(hong_kong.round).to eq(20867)
+    end
+  end
+
+  describe 'finders' do 
+    after{ clear_blockchain! }
+
+    before do
+      # < 20 km from shinjuku
+      fuchu_id = Dropzone::Item.sham!(:build, :description => 'Fuchu', 
+        :radius => 20_000, :latitude => 35.688533, 
+        :longitude => 139.471436).save! test_privkey
+
+      increment_block_height!
+
+      # 36 km from shinjuku
+      Dropzone::Item.sham!(:build, :description => 'Abiko', :radius => 20_000,
+        :latitude => 35.865683, :longitude => 140.031738).save! TESTER2_PRIVATE_KEY
+
+      # 3 km from shinjuku 
+      Dropzone::Item.sham!(:build, :description => 'Nakano', :radius => 20_000,
+        :latitude => 35.708050, :longitude => 139.664383).save! TESTER3_PRIVATE_KEY
+
+      increment_block_height!
+
+      # 38.5 km from shinjuku 
+      Dropzone::Item.sham!(:build, :description => 'Chiba', :radius => 20_000,
+        :latitude => 35.604835, :longitude => 140.105209).save! test_privkey
+
+      # This shouldn't actually be returned, since it's an update, and
+      # find_creates_since_block only looks for creates:
+      Dropzone::Item.new(create_txid: fuchu_id, 
+        description: 'xyz').save! test_privkey
+    end
+
+    it ".find_creates_since_block()" do
+      items = Dropzone::Item.find_creates_since_block block_height, block_height
+
+      expect(items.length).to eq(4)
+      expect(items.collect(&:description)).to eq(['Chiba', 'Nakano', 'Abiko', 
+        'Fuchu'])
+    end
+
+    it ".find_in_radius()" do
+      # Twenty km around Shinjuku:
+      items = Dropzone::Item.find_in_radius block_height, block_height,
+        35.689487, 139.691706, 20_000
+      expect(items.length).to eq(2)
+      expect(items.collect(&:description)).to eq(['Nakano', 'Fuchu'])
+    end
+  end
+
+
+end

data/spec/lib/fake_connection.rb

@@ -0,0 +1,97 @@
+require 'sequel'
+
+class FakeBitcoinConnection
+  attr_accessor :height, :transactions
+
+  DB ||= Sequel.sqlite # logger: Logger.new(STDOUT)
+
+  def initialize
+    DB.create_table :transactions do
+      primary_key :id
+      File :data
+      String :receiver_addr
+      String :sender_addr
+      Integer :tip
+      Integer :block_height
+    end unless DB.table_exists?(:transactions)
+
+    @height = 0
+    @transactions = DB[:transactions]
+  end
+
+  def is_testing?; true; end
+  def privkey_to_addr(key); Bitcoin::Key.from_base58(key).addr; end
+  def hash160_to_address(hash160); Bitcoin.hash160_to_address hash160; end
+  def hash160_from_address(addr); Bitcoin.hash160_from_address addr; end
+  def valid_address?(addr); Bitcoin.valid_address? addr; end
+
+  # NOTE: 
+  #  - This needs to return the messages in Descending order by block
+  #    In the case that two transactions are in the same block, it goes by time
+  #  - This should return only 'valid' messages. Not all transactions
+  def messages_by_addr(addr, options = {})
+    filter_messages transactions.where(
+      Sequel.expr(receiver_addr: addr) | Sequel.expr(sender_addr: addr) ), 
+      options
+  end
+
+  def messages_in_block(block_height, options = {})
+    filter_messages transactions.where(
+      Sequel.expr(block_height: block_height) ), options
+  end
+
+  def tx_by_id(id)
+    record_to_tx transactions[id: id.to_i]
+  end
+
+  # We ignore the private key in this connection. We return the database id 
+  # in lieue of transaction id.
+  def save!(tx, private_key)
+    transactions.insert(tx.tap{ |et| 
+      et[:block_height] = @height
+      et[:sender_addr] = privkey_to_addr(private_key)
+      et[:data] = Sequel.blob et[:data] 
+    }).to_s
+  end
+
+  # This aids test mode:
+  def clear_transactions!
+    transactions.delete
+    @height = 0
+  end
+
+  def increment_block_height!
+    @height += 1
+  end
+
+  private
+
+  def record_to_tx(record)
+    record.tap{|r| r[:txid] = r.delete(:id).to_s } if record
+  end
+
+  def filter_messages(messages, options = {})
+    if options.has_key?(:start_block)
+      messages = messages.where{block_height >= options[:start_block]} 
+    end
+    if options.has_key?(:end_block)
+      messages = messages.where{block_height <= options[:end_block]} 
+    end
+    
+    ret = messages.order(Sequel.desc(:block_height)).order(Sequel.desc(:id)).to_a
+    ret = ret.collect{ |tx| 
+      msg = Dropzone::MessageBase.new_message_from record_to_tx(tx)
+      msg.valid? ? msg : nil
+    }.compact
+
+    ret = ret.find_all{|msg| msg.message_type == options[:type]} if ret && options.has_key?(:type)
+
+    if options.has_key?(:between)
+      ret = ret.find_all{|c|
+        [c.receiver_addr, c.sender_addr].all?{|a| options[:between].include?(a) } }
+    end
+
+    (ret) ? ret : []
+  end
+end
+