DG MS; adding verification methods to importer.

lib/diaspora/importer.rb

@@ -8,13 +8,45 @@ module Diaspora
     def initialize(strategy)
       self.class.send(:include, strategy)
     end
+    
+
+    ### verification (to be module) ################
+
+    def verify(user, person, people, aspects, posts)
+      verify_user(user)
+      verify_person_for_user(user, person)
     end
  
-  module Importers
+    def verify_user(user)
+      User.find_by_id(user.id).nil? ? true : raise("User already exists!")
+    end
+
+    def verify_person_for_user(user, person)
+      local_person = Person.find_by_id(person.id)
+      if local_person
+        unless user.encryption_key.public_key.to_s == local_person.public_key.to_s
+          raise "local person found with different owner" 
+        end
+      end
+      true
+    end
+
+    def verify_people(people)
+      
+    end
+    
+  end
+
+  module Parsers
     module XML
       def execute(xml)
         doc = Nokogiri::XML.parse(xml)
+
         user, person = parse_user_and_person(doc)
+        aspects = parse_aspects(doc)
+        people = parse_people(doc)
+        posts = parse_posts(doc)
+
         user
 
       end
@@ -61,5 +93,6 @@ module Diaspora
       end
 
     end
+
   end
 end

spec/lib/importer_spec.rb

@@ -78,7 +78,7 @@ describe Diaspora::Importer do
     @user1.raw_visible_posts.find_all_by_person_id(@user1.person.id).should_not include @status_message7
   end
 
-  context 'importing a user' do
+  context 'parsing a user' do
 
     before(:each) do
       # Generate exported XML for user1
@@ -92,7 +92,7 @@ describe Diaspora::Importer do
       @user1.raw_visible_posts.find_all_by_person_id(@user1.person.id).each( &:delete )
       @user1.delete
 
-      @importer = Diaspora::Importer.new(Diaspora::Importers::XML)
+      @importer = Diaspora::Importer.new(Diaspora::Parsers::XML)
       @doc = Nokogiri::XML::parse(@xml)
     end
 
@@ -159,6 +159,16 @@ describe Diaspora::Importer do
         posts.all?(&:valid?).should be true
       end
     end
+
+    context 'verifying a user' do
+
+      describe '#verify_user' do
+        it 'should validate' do
+          verify_user(@user).should be true
+        end
+      end
+
+    end
   end
 end
 

spec/lib/verify_spec.rb

@@ -0,0 +1,56 @@
+#   Copyright (c) 2010, Diaspora Inc.  This file is
+#   licensed under the Affero General Public License version 3 or later.  See
+#   the COPYRIGHT file.
+
+require 'spec_helper'
+require File.join(Rails.root, 'lib/diaspora/importer')
+
+describe Diaspora::Importer do
+
+  let!(:user1) { Factory(:user) }
+  let!(:user2) { Factory(:user) }
+  let!(:user3) { Factory(:user) }
+
+  let(:aspect1) { user1.aspect(:name => "Work")   }
+  let(:aspect2) { user2.aspect(:name => "Family") }
+  let(:aspect3) { user3.aspect(:name => "Pivots") }
+
+  let!(:status_message1) { user1.post(:status_message, :message => "One", :public => true, :to => aspect1.id) }
+  let!(:status_message2) { user1.post(:status_message, :message => "Two", :public => true, :to => aspect1.id) }
+  let!(:status_message3) { user2.post(:status_message, :message => "Three", :public => false, :to => aspect2.id) }
+
+  let(:importer) { Diaspora::Importer.new(Diaspora::Parsers::XML) }
+
+  context 'serialized user' do
+    describe '#verify_user' do
+      it 'should return true for a new valid user' do
+        new_user = Factory(:user)
+        new_user.delete
+        importer.verify_user(new_user).should be true
+      end
+
+      it 'should return false if vaild user already exists' do
+        u = User.first
+        lambda{ importer.verify_user(user1) }.should raise_error
+      end
+    end
+
+    describe '#verify_person_for_user' do
+      it 'should pass if keys match' do
+        importer.verify_person_for_user(user1, user1.person).should be true
+      end
+
+      it 'should fail if private and public keys do not match' do
+        person = Factory(:person)
+        lambda{ importer.verify_person_for_user(user1, person) }.should raise_error
+      end
+
+      it 'should pass if the person does not exist' do 
+        user = Factory.build(:user)
+        importer.verify_person_for_user(user, user.person)
+      end
+
+    end
+      
+  end
+end