quandl_cassandra 0.3.1 → 1.0.0

data/spec/lib/quandl/cassandra_models/dataset/trim_spec.rb

@@ -1,74 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe Quandl::Cassandra::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

@@ -1,37 +0,0 @@
-# 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

@@ -1,18 +0,0 @@
-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

@@ -1,111 +0,0 @@
-require 'spec_helper'
-
-describe Quandl::Cassandra::Dataset do
-
-  let(:id){ rand(10000*10000) + 10000*10000 }
-  let(:dataset){ Quandl::Cassandra::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::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::Data.new }
-      context "given filters" do
-        subject{ dataset.data.row(0).column(1) }
-        its(:to_a){ should eq Quandl::Cassandra::Data.new }
-      end
-    end
-  end
-  
-  describe "#save" do
-    subject{ Quandl::Cassandra::Dataset.new }
-    before(:each){ subject.save }
-    its(:new_record?){ should be_true }
-  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::Dataset.find(id) }
-        its(:data){ should eq dataset.data.to_table }
-        its(:frequency){ should eq 'daily' }
-        
-        describe "#columns" do
-          subject{ Quandl::Cassandra::Dataset.find(id).columns }
-          its(:first){ should be_a Quandl::Cassandra::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::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::ColumnAttribute }
-      end
-    
-    end
-  
-  end
-  
-end

data/spec/lib/quandl/cassandra_models/multiset/collapse_spec.rb

@@ -1,122 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe Multiset do
-  
-  context "collapse" do
-  
-    let(:d1){ create(:dataset) }
-    let(:d2){ create(:dataset) }
-    subject { Multiset.with_columns("#{d2.id.to_i}.1,#{d1.id.to_i}.1,#{d2.id.to_i}.3,#{d1.id.to_i}.2") }
-  
-    it "should change the scope" do
-      scope = subject.data.collapse('weekly')
-      scope.attributes[:collapse].should eq :weekly
-    end
-    
-    it "should accept daily" do
-      subject.data.collapse(:daily).count.should eq 60
-    end
-    
-    it "should accept weekly" do
-      subject.data.collapse(:weekly).count.should be < 12
-    end
-    
-    it "should accept monthly" do
-      subject.data.collapse(:monthly).count.should be < 4
-    end
-  
-    it "should accept annual" do
-      subject.data.collapse(:annual).count.should eq 1
-    end
-    
-  end
-  
-  context "multiple frequencies" do
-    
-    let(:dataset_daily)   { create(:dataset, data: Quandl::Fabricate::Data.rand( rows: 10, columns: 3, nils: false ).to_csv ) }
-    let(:dataset_monthly) { create(:dataset, data: Quandl::Fabricate::Data.rand( rows: 10, columns: 3, frequency: :monthly, nils: false ).to_csv ) }
-    let(:dataset_annual)  { create(:dataset, data: Quandl::Fabricate::Data.rand( rows: 10, columns: 3, frequency: :annual, nils: false ).to_csv ) }
-    
-    context "without collapse" do
-      
-      subject { Multiset.with_columns("#{dataset_daily.id.to_i}.1,#{dataset_monthly.id.to_i}.1,#{dataset_annual.id.to_i}.1") }
-      
-      describe "#data" do
-        
-        it "should be correct" do
-          row = subject.data[0]
-          row[1].should eq Dataset.find(dataset_daily.id).data[0][1]
-          row[2].should eq Dataset.find(dataset_monthly.id).data[0][1]
-          row[3].should eq Dataset.find(dataset_annual.id).data[0][1]
-        end
-        
-      end
-      
-      describe "#column_frequencies" do
-        
-        it "should be correct" do
-          subject.column_frequencies[0].should eq 'daily'
-          subject.column_frequencies[1].should eq 'monthly'
-          subject.column_frequencies[2].should eq 'annual'
-        end
-        
-      end
-      
-    end
-    
-    context "collapsed to annual" do
-      
-      subject { 
-        m = Multiset.with_columns("#{dataset_daily.id.to_i}.1,#{dataset_monthly.id.to_i}.1,#{dataset_annual.id.to_i}.1") 
-        m.data.collapse(:annual)
-        m
-      }
-      
-      it "should return the data" do
-        data_hash = subject.data.scoped.collapse(:annual).to_table.to_h
-        # check daily
-        daily_row = Dataset.find(dataset_daily.id).data.column(1).collapse(:annual)
-        daily_date = daily_row[0][0]
-        data_hash[daily_date][0].should eq daily_row[0][1]
-        # check monthly
-        monthly_row = Dataset.find(dataset_monthly.id).data.column(1).collapse(:annual)
-        monthly_date = monthly_row[0][0]
-        data_hash[monthly_date][1].should eq monthly_row[0][1]
-        # check annual
-        annual_row = Dataset.find(dataset_annual.id).data.column(1).collapse(:annual)
-        annual_date = annual_row[0][0]
-        data_hash[annual_date][2].should eq annual_row[0][1]
-      end
-      
-    end
-    
-    context "collapsed to monthly" do
-      
-      subject { 
-        m = Multiset.with_columns("#{dataset_daily.id.to_i}.1,#{dataset_monthly.id.to_i}.1,#{dataset_annual.id.to_i}.1") 
-        m.data.collapse(:monthly)
-        m
-      }
-      
-      it "should return the data" do
-        data_hash = subject.data.to_table.to_h
-        # check daily
-        daily_row = Dataset.find(dataset_daily.id).data.column(1).collapse(:monthly)
-        daily_date = daily_row[0][0]
-        data_hash[daily_date][0].should eq daily_row[0][1]
-        # check monthly
-        monthly_row = Dataset.find(dataset_monthly.id).data.column(1).collapse(:monthly)
-        monthly_date = monthly_row[0][0]
-        data_hash[monthly_date][1].should eq monthly_row[0][1]
-        # check annual
-        annual_row = Dataset.find(dataset_annual.id).data.column(1).collapse(:monthly)
-        annual_date = annual_row[0][0]
-        data_hash[annual_date][2].should eq annual_row[0][1]
-      end
-      
-    end
-    
-  end
-  
-end

data/spec/lib/quandl/cassandra_models/multiset/columns_spec.rb

@@ -1,57 +0,0 @@
- # encoding: utf-8
-require 'spec_helper'
-
-describe Multiset do
-  
-  context "columns" do
-  
-    let(:d1){ create(:dataset) }
-    let(:d2){ create(:dataset) }
-    
-    let(:multiset){ Multiset.with_columns("#{d2.id.to_i}.2,#{d1.id.to_i}.2,#{d2.id.to_i}.4,#{d1.id.to_i}.3") }
-    
-    describe ".with_columns" do
-      subject{ multiset }
-      
-      describe "#column_ids" do
-        subject{ multiset.column_ids }
-        its([0]){ should be_same_string_as Dataset.find(d2.id).column_ids[1] }
-        its([1]){ should be_same_string_as Dataset.find(d1.id).column_ids[1] }
-        its([2]){ should be_same_string_as Dataset.find(d2.id).column_ids[3] }
-        its([3]){ should be_same_string_as Dataset.find(d1.id).column_ids[2] }
-      end
-      
-      describe "#data" do
-        subject{ multiset.data.to_a }
-        its(:count){ should eq 60 }
-        
-        describe "#first" do
-          subject{ multiset.data.to_a.first }
-          its(:count){ should eq 5 }
-        end
-        
-      end
-      
-    end
-    
-    it "should limit the data" do
-      data = Multiset.with_columns("#{d1.id.to_i}.2,#{d2.id.to_i}.1").data.limit(10)
-      data.count.should eq 10
-    end
-    
-    it "should return the correct data" do
-      d = Multiset.with_columns("#{d1.id.to_i}.2,#{d2.id.to_i}.1")
-      d.data[0][1].should eq Dataset.find(d1.id).data[0][2]
-      d.data[0][2].should eq Dataset.find(d2.id).data[0][1]
-    end
-    
-    it "should transform the data" do
-      d = Multiset.with_columns("#{d1.id.to_i}.2,#{d2.id.to_i}.1")
-      data = d.data.limit(1).transform(:rdiff)
-      plain_data = Multiset.with_columns("#{d1.id.to_i}.2,#{d2.id.to_i}.1").data.limit(1)
-      data[0][1].should_not eq plain_data[0][1]
-    end
-    
-  end
-  
-end

data/spec/lib/quandl/cassandra_models/multiset/data_spec.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe Multiset do
-  
-  context "data" do
-  
-    let(:d1){ create(:dataset) }
-    let(:d2){ create(:dataset) }
-    subject { Multiset.with_columns("#{d2.id.to_i}.1,#{d1.id.to_i}.1,#{d2.id.to_i}.3,#{d1.id.to_i}.2") }
-    # wait for cassandra to be eventually consistent
-  
-    it "should have columns" do
-      subject.columns.count.should eq 4
-    end
-  
-    it "should have data" do
-      subject.data.count.should eq 60
-    end
-    
-    its(:to_json){ should be_present }
-    
-  end
-  
-end