quandl_cassandra_models 0.3.6

data/spec/lib/quandl/cassandra/models/column_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Quandl::Cassandra::Models::Column do
+  
+  let(:id){ rand(10000*10000) + 10000*10000 }
+  let(:data){ Quandl::Fabricate::Data.rand( rows: 10, columns: 2, nils: false ) }
+  let(:dataset){ Quandl::Cassandra::Models::Dataset.create( id: id, data: data ) }
+  
+  describe ".read" do
+    before(:each){ Quandl::Cassandra::Models::Column.write( id: id, data: data ); sleep(0.2) }
+    
+    subject{ Quandl::Cassandra::Models::Column.read( id: id ) }
+    its(:count){ should eq 10 }
+    it{ should eq data }
+  end
+  
+end

data/spec/lib/quandl/cassandra/models/data_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe Quandl::Cassandra::Models::Data do
+
+  let(:id){ rand(10000*10000) + 10000*10000 }
+  let(:data){ Quandl::Fabricate::Data.rand(rows: 10, columns: 2, nils: false) }
+  let(:dataset){ Quandl::Cassandra::Models::Dataset.create( id: id, data: data ) }
+  subject{ Quandl::Cassandra::Models::Data }
+  
+  [:row, :id, :limit, :offset, :column, :accuracy, :frequency, :column_ids,
+    :collapse, :transform, :order, :trim_start, :trim_end ].each do |name|
+    it{ should respond_to name }
+  end
+  
+  describe "#column" do
+    it "should handle column that is outside the range of available columns" do
+      dataset.data.scoped.column(4).to_table.should be_blank
+    end
+  end
+  
+  describe "#collapse" do
+    it "should become annual" do
+      scope = subject.collapse(:annual)
+      scope.attributes[:collapse].should eq :annual
+    end
+    it "should become annual given string" do
+      scope = subject.collapse('annual')
+      scope.attributes[:collapse].should eq :annual
+    end
+    it "should become monthly" do
+      scope = subject.collapse(:monthly)
+      scope.attributes[:collapse].should eq :monthly
+    end
+    it "should become weekly" do
+      scope = subject.collapse('weekly')
+      scope.attributes[:collapse].should eq :weekly
+    end
+  end
+  
+  describe "#trim_start & #trim_end" do
+    it "should handle trim_start > trim_end" do
+      dataset.data.scoped.trim_start(data[-1][0]).trim_end(data[0][0]).to_table.should be_a Quandl::Cassandra::Data
+    end
+  end
+    
+  describe "#trim_start" do
+    
+    subject{ dataset.data }
+    
+    context "given invalid date" do
+        
+      it "rejects string" do
+        subject.trim_start('invalid').attributes[:trim_start].should be_nil
+      end
+        
+    end
+      
+    context "given valid date" do
+        
+      it "accepts string" do
+        subject.trim_start('1980-01-01').attributes[:trim_start].should eq Date.parse('1980-01-01').jd
+      end
+        
+      it "accepts julian date" do
+        subject.trim_start( Date.today.jd ).attributes[:trim_start].should eq Date.today.jd
+      end
+        
+    end
+      
+  end
+    
+  describe "#trim_end" do
+    
+    subject{ dataset.data }
+    
+    context "given invalid date" do
+      it "rejects string" do
+        subject.trim_end('invalid').attributes[:trim_end].should be_nil
+      end
+    end
+    context "given valid date" do
+      it "accepts date" do
+        subject.trim_end(Date.today).attributes[:trim_end].should eq Date.today.jd
+      end
+      it "accepts string" do
+        subject.trim_end('1980-01-01').attributes[:trim_end].should eq Date.parse('1980-01-01').jd
+      end
+      it "accepts julian date" do
+        subject.trim_end( Date.today.jd ).attributes[:trim_end].should eq Date.today.jd
+      end
+    end
+  end
+  
+  context "data with empty columns" do
+    let(:data){ Quandl::Data.new("2012-12-31,21.0,11.0,12.0,0.0,,,,0.0,,4.0,,4.0,18.0,19.0\n2012-12-24,21.0,11.0,12.0,0.0,,,,0.0,,4.0,,4.0,18.0,19.0\n2012-12-18,21.0,11.0,12.0,0.0,,,,0.0,,4.0,,4.0,18.0,19.0\n") }
+    let(:dataset){ Quandl::Cassandra::Models::Dataset.create( id: rand(100000), data: data ) }
+    subject{ Dataset.find(dataset.id) }
+    
+    it "should eq data" do
+      subject.data.to_table.should eq data
+    end
+    
+  end
+    
+end

data/spec/lib/quandl/cassandra/models/dataset/collapse_spec.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Quandl::Cassandra::Models::Dataset do
+  
+  let(:dataset){ create(:dataset) }
+  subject { dataset }
+  
+  it "should have columns" do
+    subject.columns.count.should eq 4
+  end
+  
+  describe "#data" do
+    
+    subject{ dataset.data }
+    
+    its(:class){ should eq Quandl::Cassandra::Models::Data::ScopeScope }
+    
+    its(:to_date){ should be_present }
+    its(:to_h){ should be_present }
+    
+    it "should have data" do
+      subject.count.should eq 60
+    end
+  
+    it "should collapse to daily" do
+      subject.collapse(:daily).count.should eq 60
+    end
+  
+    it "should collapse to weekly" do
+      subject.collapse(:weekly).count.should be < 12
+    end
+  
+    it "should collapse to monthly" do
+      subject.collapse(:monthly).count.should be < 4
+    end
+
+    it "should collapse to annual" do
+      subject.collapse(:annual).count.should eq 1
+    end
+  
+  end
+
+end

data/spec/lib/quandl/cassandra/models/dataset/column_spec.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Quandl::Cassandra::Models::Dataset do
+  
+  context "column" do
+    
+    subject { create(:dataset) }
+    
+    it "should return first column" do
+      subject.data.column(1)[0][1].should eq subject.data.scoped.to_table[0][1]
+    end
+    
+    it "should return second column" do
+      subject.data.column(2)[0][1].should eq subject.data.scoped.to_table[0][2]
+    end
+    
+    it "should return third column" do
+      subject.data.column(2)[0][1].should eq subject.data.scoped.to_table[0][2]
+    end
+    
+  end
+  
+end

data/spec/lib/quandl/cassandra/models/dataset/persistence_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Quandl::Cassandra::Models::Dataset do
+  
+  let(:data){ Quandl::Fabricate::Data.rand( rows: 4, columns: 4, nils: false ) }
+  let(:dataset){ create( :dataset, data: data ) }
+  
+  subject{ dataset }
+  
+  its(:dataset_attribute){ should be_a DatasetAttribute }
+  its(:trim_start){ should eq Date.jd(Dataset.find(dataset.id).data[-1][0]) }
+  its(:trim_end){ should eq Date.jd(Dataset.find(dataset.id).data[0][0]) }
+  its(:updated_at){ should_not be_nil }
+  
+  context "after save" do
+    before(:each){ 
+      @previously_updated_at = subject.updated_at
+      subject.data = Quandl::Fabricate::Data.rand( rows: 4, columns: 4, nils: false )
+      subject.save
+    }
+    its(:updated_at){ should_not eq @previously_updated_at }
+  end
+  
+end

data/spec/lib/quandl/cassandra/models/dataset/row_spec.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Quandl::Cassandra::Models::Dataset do
+  
+  let(:data){ Quandl::Fabricate::Data.rand( rows: 216, columns: 2, frequency: :weekly, nils: false ).to_csv }
+  let(:dataset){ create( :dataset, data: data ) }
+  subject { dataset }
+  
+  it "should be monthly" do
+    subject.frequency.should eq 'weekly'
+  end
+  
+  it "should pluck the second row" do
+    subject.data.scoped.collapse(:monthly).row(1).to_a.should eq [subject.data.scoped.collapse(:monthly)[1]]
+  end
+  
+  it "should collapse and pluck the second year" do
+    subject.data.scoped.collapse(:annual).row(2).to_a.should eq [subject.data.scoped.collapse(:annual)[2]]
+  end
+  
+  it "should collapse and pluck the second year with a transformation" do
+    subject.data.scoped.collapse(:annual).transform(:rdiff).row(2).to_a.should eq [subject.data.scoped.collapse(:annual).transform(:rdiff)[2]]
+  end
+  
+end

data/spec/lib/quandl/cassandra/models/dataset/transform_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Dataset do
+  
+  let(:data){ Quandl::Data.new([ [1002, 10], [1001, 20], [1000, 30] ]) }
+  let(:dataset){ build(:dataset) }
+
+  it "should cumul data" do
+    dataset.data = data
+    dataset.save!
+    cumul_data = Dataset.find(dataset.id).data.transform(:cumul).to_table.data_array
+    cumul_data.should eq [ [1002, 60.0], [1001, 50.0], [1000, 30.0] ]
+  end
+  
+end

data/spec/lib/quandl/cassandra/models/dataset/trim_spec.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Quandl::Cassandra::Models::Dataset do
+  
+  describe ".trim_start,.trim_end" do
+    { weekly: 7, monthly: 30, quarterly: 92, annual: 365 }.each do | collapse_to, occurences |
+      context "when collapsed to #{collapse_to}" do
+
+        subject(:dataset){ create(:dataset, data: Quandl::Fabricate::Data.rand( rows: occurences * 3, columns: 1, nils: false ).to_csv ) }
+        
+        it "should include trim_start" do
+          # raw data
+          source_data = subject.data.scoped.collapse(collapse_to).to_table
+          trim_start = source_data[-1][0]
+          # trim and check
+          trim_data = subject.data.trim_start( trim_start ).collapse(collapse_to).to_table
+          trim_data.last[0].should eq trim_start
+        end
+        it "should include trim_end" do
+          # raw data
+          source_data = subject.data.scoped.collapse(collapse_to).to_table
+          trim_end = source_data[1][0]
+          # trim and check
+          trim_data = subject.data.trim_end( trim_end ).collapse(collapse_to).to_table
+          trim_data.first[0].should eq trim_end
+        end
+        it "should include trim_start and trim_end" do
+          # raw data
+          source_data = subject.data.scoped.collapse(collapse_to).to_table
+          trim_end = source_data[1][0]
+          trim_start = source_data[-1][0]
+          # trim and check
+          trim_data = subject.data.trim_start( trim_start ).trim_end( trim_end ).collapse(collapse_to).to_table
+          trim_data.first[0].should eq trim_end
+          trim_data.last[0].should eq trim_start
+        end
+        
+        [:diff, :rdiff, :cumul].each do |transformed_to|
+          context "when transformed to #{transformed_to}" do
+            it "should include trim_start" do
+              # raw data
+              source_data = subject.data.scoped.collapse(collapse_to).transform(transformed_to).to_table
+              trim_start = source_data[-1][0]
+              # trim and check
+              trim_data = subject.data.trim_start( trim_start ).transform(transformed_to).collapse(collapse_to).to_table
+              trim_data.last[0].should eq trim_start
+            end
+            it "should include trim_end" do
+              # raw data
+              source_data = subject.data.scoped.collapse(collapse_to).transform(transformed_to).to_table
+              trim_end = source_data[-1][0]
+              # trim and check
+              trim_data = subject.data.trim_end( trim_end ).transform(transformed_to).collapse(collapse_to).to_table
+              trim_data.first[0].should eq trim_end
+            end
+            it "should include trim_start and trim_end" do
+              source_data = subject.data.scoped.collapse(collapse_to).transform(transformed_to).to_table
+              trim_end = source_data[1][0]
+              trim_start = source_data[-1][0]
+              # trim and check
+              trim_data = subject.data.trim_start( trim_start ).trim_end( trim_end ).transform(transformed_to).collapse(collapse_to).to_table
+              trim_data.first[0].should eq trim_end
+              trim_data.last[0].should eq trim_start
+            end
+          end # each transform
+
+        end
+        
+      end # each collapse
+    end
+  end
+  
+end

data/spec/lib/quandl/cassandra/models/dataset/update_spec.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Dataset do
+
+  context "update data with newer data" do
+    
+    subject{ create(:dataset, data: Quandl::Fabricate::Data.rand( rows: 730, columns: 2, nils: false ).to_csv ) }
+    
+    it "should update the collapse data" do
+      old_row = subject.data.scoped[0]
+      old_row_month = subject.data.scoped.collapse(:monthly)[0]
+      # update
+      dataset = Dataset.find(subject.id)
+      # advance data dates by 60 days
+      new_data = subject.data.collect{|r|
+        date = r[0] + 60
+        values = r[1..-1].collect{ rand(9102841).to_f / 1000 }
+        [date, values].flatten
+      }
+      # assign new data
+      dataset.data = new_data.to_a.collect{|r| r.to_csv }.join
+      dataset.save!
+      
+      new_row = dataset.data.scoped[0]
+      new_row_month = dataset.data.scoped.collapse(:monthly)[0]
+      
+      new_row[0].should_not eq new_row_month[0]
+      new_row[1].should eq new_row_month[1]
+      
+      old_row[0].should_not eq new_row[0]
+      old_row_month[1].should_not eq new_row_month[1]
+    end
+    
+  end
+  
+end

data/spec/lib/quandl/cassandra/models/dataset_attribute_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe DatasetAttribute do
+  let(:id){ rand(10000*10000) + 10000*10000 }
+  let(:dataset_attribute){ DatasetAttribute.create( id: id ) }
+  subject{ dataset_attribute }
+  
+  its(:updated_at){ should be_present }
+  its(:created_at){ should be_present }
+  
+  describe ".find" do
+    subject{ DatasetAttribute.find( dataset_attribute.id ) }
+    it{ should be_a DatasetAttribute }
+    its(:updated_at){ should be_same_second_as dataset_attribute.updated_at }
+    its(:created_at){ should be_same_second_as dataset_attribute.created_at }
+  end
+  
+end

data/spec/lib/quandl/cassandra/models/dataset_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe Quandl::Cassandra::Models::Dataset do
+
+  let(:id){ rand(10000*10000) + 10000*10000 }
+  let(:dataset){ Quandl::Cassandra::Models::Dataset.new( id: id ) }
+  subject{ dataset }
+  
+  it{ should respond_to :id }
+  it{ should respond_to :data }
+  it{ should respond_to :column_ids }
+  
+  its(:id){ should eq id }
+  its(:changes){ should eq( { "id" => [nil, id] }) }
+  
+  describe ".new" do
+    let(:dataset){ Quandl::Cassandra::Models::Dataset.new( id: 0 ) }
+    subject{ dataset }
+    its(:data){ should eq [] }
+    its(:column_ids){ should eq [] }
+    its(:columns){ should eq [] }
+    describe "#data" do
+      subject{ dataset.data }
+      its(:count){ should eq 0 }
+      its(:to_a){ should eq Quandl::Cassandra::Models::Data.new }
+      context "given filters" do
+        subject{ dataset.data.row(0).column(1) }
+        its(:to_a){ should eq Quandl::Cassandra::Models::Data.new }
+      end
+    end
+  end
+  
+  describe "#data=" do
+    it "should accept data with dates" do
+      subject.data = Quandl::Fabricate::Data.rand(rows: 10, columns: 2, nils: false).to_date.to_a
+      subject.save.should be_true
+    end
+  end
+  
+  describe "#save" do
+    subject{ Quandl::Cassandra::Models::Dataset.new }
+    before(:each){ subject.save }
+  end
+  
+  describe "#class" do
+    subject{ dataset.class }
+    its(:table_name){ should eq 'datasets' }
+  end
+  
+  context "given data" do
+    before(:each){ dataset.data = Quandl::Fabricate::Data.rand(rows: 10, columns: 2, nils: false) }
+  
+    describe "#save" do
+      before(:each){ dataset.save }
+    
+      subject{ dataset }
+    
+      its(:changes){ should be_blank }
+      its(:frequency){ should eq 'daily' }
+    
+      describe ".find" do
+        subject{ Quandl::Cassandra::Models::Dataset.find(id) }
+        its(:data){ should eq dataset.data.to_table }
+        its(:frequency){ should eq 'daily' }
+        
+        describe "#columns" do
+          subject{ Quandl::Cassandra::Models::Dataset.find(id).columns }
+          its(:first){ should be_a Quandl::Cassandra::Models::ColumnAttribute }
+        end
+        
+        it "data should count and return data" do
+          subject.data.count.should eq 10
+          subject.data.to_table.should be_a Quandl::Cassandra::Models::Data
+        end
+        it "columns should eq dataset.columns" do
+          subject.columns.collect{|c| c.id.to_s }.should eq dataset.columns.collect{|c| c.id.to_s }
+        end
+        it "column_ids should eq dataset.column_ids" do
+          subject.column_ids.collect(&:to_s).should eq dataset.column_ids.collect(&:to_s)
+        end
+      end
+    
+      describe "#reload" do
+        before(:each){ 
+          dataset.data.limit(5).to_a
+          dataset.reload
+        }
+      
+        describe "#attributes" do
+          subject{ dataset.attributes }
+          its([:data]){ should eq nil }
+        end
+      
+      end
+    
+      describe "#data" do
+        subject{ dataset.data }
+        its(:count){ should eq 10 }
+      end
+
+      describe "#column_ids" do
+        subject{ dataset.column_ids }
+        its(:count){ should eq 2 }
+        its(:first){ should be_a Cql::Uuid }
+      end
+    
+      describe "#columns" do
+        subject{ dataset.columns }
+        its(:count){ should eq 2 }
+        its(:first){ should be_a Quandl::Cassandra::Models::ColumnAttribute }
+      end
+    
+    end
+  
+  end
+  
+end