gmailish 0.0.1

data/lib/gmailish/version.rb

@@ -0,0 +1,3 @@
+module Gmailish
+  VERSION = "0.0.1"
+end

data/spec/gmailish_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+require_relative 'support/data'
+
+module Gmailish
+  describe Gmailish do
+    let(:instance) { Gmailish::Account.new(username, password) }
+    let(:username) { 'venkmanapp' }
+    let(:password) { 'ABC123456' }
+
+    let(:account) {
+      fire_double(
+        'Net::IMAP'
+      )
+    }
+
+    let(:tagged_response) {
+      fire_double(
+        'Net::IMAP::TaggedResponse',
+        :name => 'OK'
+      )
+    }
+
+    let(:fetch_data) {
+      fire_double(
+        'Net::IMAP::FetchData',
+        :attr => Gmailish::SupportData.fake_fetch_data_response
+      )
+    }
+
+    context 'invalid' do
+      subject { instance.process }
+
+      it 'raises error' do
+        expect { subject }.to raise_error(Net::IMAP::NoResponseError)
+      end
+    end
+
+    context 'valid' do
+      subject { instance.process }
+
+      let(:address) { 'imap.gmail.com' }
+      let(:port) { 993 }
+
+      let(:mailbox) { 'inbox' }
+      let(:read_label) { :Seen }
+      let(:unread_label) { 'UNSEEN' }
+      let(:delete_label) { :Deleted }
+      let(:transfered_label) { 'Transfered' }
+      let(:archive_label) { "[Gmail]/All Mail" }
+      let(:uid) { 110 }
+      let(:rfc) { 'RFC822' }
+
+      let(:mail_subject) {
+        "Fwd: Raising and Rescuing Custom Errors in Rails | We Are Stac"
+      }
+
+      let(:mail_to) {
+        ["venkmanapp+40f7f061c2f7254b1b50f699d9eac16a@gmail.com"]
+      }
+
+      let(:mail_from) {
+        ["chuckjhardy@gmail.com"]
+      }
+
+      it 'returns messages' do
+        # Create connection
+        Net::IMAP.should_receive(:new).
+          with(address, port, true, nil, false).
+          and_return(account)
+
+        # Login to account
+        account.should_receive(:login).
+          with(username, password).
+          and_return(tagged_response)
+
+        # Select Inbox
+        account.should_receive(:select).
+          with(mailbox).
+          and_return(tagged_response)
+
+        # Find unread messages
+        account.should_receive(:uid_search).
+          with([unread_label]).
+          and_return([uid])
+
+        # Get unread messages
+        account.should_receive(:uid_fetch).
+          with(uid, rfc).
+          and_return(fetch_data)
+
+        # Add 'Transfered' label to messages
+        account.should_receive(:uid_copy).
+          with(uid, transfered_label).
+          and_return(tagged_response)
+
+        # Make messages as read
+        account.should_receive(:uid_store).
+          with(uid, "+FLAGS", [read_label]).
+          and_return(tagged_response)
+
+        # Archive messages
+        account.should_receive(:uid_copy).
+          with(uid, archive_label).
+          and_return(tagged_response)
+
+        # Delete messages from inbox
+        account.should_receive(:uid_store).
+          with(uid, "+FLAGS", [delete_label]).
+          and_return(tagged_response)
+
+        # Logout of account
+        account.should_receive(:logout).
+          and_return(tagged_response)
+
+        # Always returns an array
+        expect(subject.messages).to be_an_instance_of(Array)
+
+        # Array contains Mail objects
+        expect(subject.messages.first).to be_an_instance_of(Mail::Message)
+
+        # Message has a subject
+        expect(subject.messages.first.subject).to eq(mail_subject)
+
+        # Message has a to field
+        expect(subject.messages.first.to).to eq(mail_to)
+
+        # Message has a from field
+        expect(subject.messages.first.from).to eq(mail_from)
+
+        # Message has a body field
+        expect(subject.messages.first.body).to be_an_instance_of(Mail::Body)
+      end
+    end
+  end
+end

data/spec/lib/gmailish/account_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+module Gmailish
+  describe Account do
+    let(:instance) { Gmailish::Account.new(username, password) }
+    let(:username) { 'venkmanapp' }
+    let(:password) { 'ABC123456' }
+
+    let(:account) {
+      fire_double(
+        'Net::IMAP'
+      )
+    }
+
+    describe '#initialize' do
+      it 'take arguments' do
+        instance
+      end
+    end
+
+    describe '.process' do
+      subject { described_class.process(username, password) }
+
+      it 'calls off to process' do
+        described_class.any_instance.should_receive(:process)
+
+        subject
+      end
+    end
+
+    describe '#process' do
+      subject { instance.process }
+
+      let(:actions) {
+        fire_double(
+          'Gmailish::Actions'
+        )
+      }
+
+      let(:messages) { lambda{} }
+
+      let(:address) { 'imap.gmail.com' }
+      let(:port) { 993 }
+
+      before { instance.stub(:messages => messages) }
+
+      it 'calls off to actions and return self' do
+        Net::IMAP.should_receive(:new).
+          with(address, port, true, nil, false).
+          and_return(account)
+
+        Actions.should_receive(:new).
+          with(account, username, password).
+          and_return(actions)
+
+        actions.should_receive(:process)
+
+        expect(subject).to be_an_instance_of(Gmailish::Account)
+      end
+    end
+
+    describe '#messages' do
+      subject { instance.messages }
+
+      let(:label) { 'UNSEEN' }
+      let(:uid) { 37 }
+      let(:uids) { [ uid ] }
+      let(:message) {
+        fire_double(
+          'Gmailish::Message'
+        )
+      }
+
+      before { instance.stub(:account => account) }
+
+      it 'returns array of message objects' do
+        account.should_receive(:uid_search).
+          with([label]).
+          and_return(uids)
+
+        Message.should_receive(:process).
+          with(account, uid).
+          and_return(message)
+
+        expect(subject).to eq([message])
+      end
+    end
+  end
+end

data/spec/lib/gmailish/actions_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+module Gmailish
+  describe Actions do
+    let(:instance) { Gmailish::Actions.new(account, username, password) }
+    let(:username) { 'venkmanapp' }
+    let(:password) { 'ABC123456' }
+    let(:account) {
+      fire_double(
+        'Net::IMAP'
+      )
+    }
+
+    let(:message) {
+      fire_double(
+        'Gmailish::Message'
+      )
+    }
+
+    let(:response) {
+      fire_double(
+        'Net::IMAP::TaggedResponse',
+        :name => 'OK'
+      )
+    }
+
+    describe '#initialize' do
+      it 'take arguments' do
+        instance
+      end
+    end
+
+    describe '#process' do
+      context 'called with message' do
+        subject { instance.process { message } }
+
+        it 'calls actions in order' do
+          instance.should_receive(:login)
+          instance.should_receive(:inbox)
+          instance.should_receive(:logout)
+
+          subject
+        end
+
+        context 'login' do
+          before do
+            instance.stub(:inbox)
+            instance.stub(:logout)
+          end
+
+          it 'sets logged_in to true' do
+            account.should_receive(:login).
+              with(username, password).
+              and_return(response)
+
+            subject
+
+            expect(instance.logged_in).to be_true
+          end
+        end
+
+        context 'inbox' do
+          before do
+            instance.stub(:login)
+            instance.stub(:logout)
+          end
+
+          let(:inbox) { 'inbox' }
+
+          it 'selects inbox' do
+            account.should_receive(:select).
+              with(inbox)
+
+            subject
+          end
+        end
+
+        context 'logout' do
+          let(:response) { nil }
+
+          before do
+            instance.stub(:login)
+            instance.stub(:inbox)
+          end
+
+          it 'sets logged_in to false' do
+            account.should_receive(:logout).
+              and_return(response)
+
+            subject
+
+            expect(instance.logged_in).to be_false
+          end
+        end
+      end
+
+      context 'called without message' do
+        subject { instance.process }
+
+        let(:msg) { "Messages must be passed within a block." }
+
+        it 'raises error' do
+          expect { subject }.to raise_error(Error::NoMessageError, msg)
+        end
+      end
+    end
+
+    describe '#logged_in?' do
+      subject { instance.logged_in? }
+
+      it 'returns false' do
+        expect(subject).to be_false
+      end
+    end
+  end
+end

data/spec/lib/gmailish/error_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module Gmailish
+  describe Error do
+    let(:dummy_class) { Class.new { include Gmailish::Error }.new }
+
+    describe Error::NoMessageError do
+      it 'raises error' do
+        expect { raise Error::NoMessageError }.to raise_error
+      end
+    end
+
+    describe Error::NoLabelError do
+      it 'raises error' do
+        expect { raise Error::NoLabelError }.to raise_error
+      end
+    end
+  end
+end

data/spec/lib/gmailish/flagger_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+module Gmailish
+  describe Flagger do
+    let(:instance) { Gmailish::Flagger.new(account, uid) }
+    let(:uid) { 37 }
+    let(:account) {
+      fire_double(
+        'Net::IMAP'
+      )
+    }
+
+    describe '#initialize' do
+      it 'take arguments' do
+        instance
+      end
+    end
+
+    describe '#delete' do
+      subject { instance.delete }
+
+      let(:label) { :Deleted }
+
+      it 'calls uid_store with expected arguments' do
+        account.should_receive(:uid_store).
+          with(uid, "+FLAGS", [label])
+
+        subject
+      end
+    end
+
+    describe '#unread' do
+      subject { instance.unread }
+
+      let(:label) { :Seen }
+
+      it 'calls uid_store with expected arguments' do
+        account.should_receive(:uid_store).
+          with(uid, "+FLAGS", [label])
+
+        subject
+      end
+    end
+  end
+end

data/spec/lib/gmailish/labeler_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+module Gmailish
+  describe Labeler do
+    let(:instance) { Gmailish::Labeler.new(account, uid) }
+    let(:uid) { 37 }
+    let(:account) {
+      fire_double(
+        'Net::IMAP'
+      )
+    }
+
+    let(:uid_copy) { stub }
+
+    describe '#initialize' do
+      it 'takes arguments' do
+        instance
+      end
+    end
+
+    describe '#transfered' do
+      subject { instance.transfered }
+
+      let(:label) { 'Transfered' }
+
+      context 'label exists' do
+        it 'returns response' do
+          account.should_receive(:uid_copy).
+            with(uid, label)
+
+          subject
+        end
+      end
+
+      context 'label does not exist' do
+        let(:msg) { "Manually create `#{label}' label." }
+
+        it 'raise error' do
+          account.should_receive(:uid_copy).
+            with(uid, label).
+            and_raise
+
+          expect { subject }.to raise_error(Error::NoLabelError, msg)
+        end
+      end
+    end
+
+    describe '#all_mail' do
+      subject { instance.all_mail }
+
+      let(:label) { '[Gmail]/All Mail' }
+
+      context 'label exists' do
+        it 'returns response' do
+          account.should_receive(:uid_copy).
+            with(uid, label)
+
+          subject
+        end
+      end
+
+      context 'label does not exist' do
+        let(:msg) { "Manually create `#{label}' label." }
+
+        it 'raise error' do
+          account.should_receive(:uid_copy).
+            with(uid, label).
+            and_raise
+
+          expect { subject }.to raise_error(Error::NoLabelError, msg)
+        end
+      end
+    end
+  end
+end