Gemnigma 0.0.2

data/spec/decrypt_spec.rb

@@ -0,0 +1,108 @@
+require_relative "spec_helper"
+
+describe Gemnigma::Decrypt do
+  before :each do
+    @dec = Gemnigma::Decrypt.new
+  end
+
+  it "should be a subclass of RotatorDecrypt" do
+    expect(Gemnigma::Decrypt.superclass).to eql(Gemnigma::RotatorDecrypt)
+  end
+
+  it "should be an instance of the class Decrypt" do
+    expect(@dec).to be_an_instance_of Gemnigma::Decrypt
+  end
+
+  describe "#get_cmd_args" do
+    it "should take no arguments" do
+      expect{ @dec.get_cmd_args(123) }.to raise_error(ArgumentError)
+    end
+
+   it "should display an error message if few arguments are passed as command line arguments" do
+
+      io = double("io", puts: nil)
+      message = Gemnigma::Messages.new(io)
+      message.few_args
+
+      expect(io).to have_received(:puts).with("Not enough arguments passed in. Run Gemnigma --help for instructions on usage\nExiting...")
+    end
+
+    it "should display an error message if too many arguments are passed as command line arguments" do
+
+      io = double("io", puts: nil)
+      message = Gemnigma::Messages.new(io)
+      message.too_much_args
+
+      expect(io).to have_received(:puts).with("Too many arguments passed in. Run Gemnigma --help for instructions on usage\nExiting...")
+    end
+  end
+
+  describe "#true_key?" do
+    it "should be a private method" do
+      expect{ @dec.true_key? }.to raise_error (NoMethodError)
+    end
+
+    it "should take one argument only" do
+      expect{ @dec.send(:true_key?) }.to raise_error(ArgumentError)
+      expect{ @dec.send(:true_key?, "41521", "32415") }.to raise_error(ArgumentError)
+    end
+
+    it "should return true for valid keys" do
+      expect(@dec.send(:true_key?, "31292")).to be true
+      expect(@dec.send(:true_key?, "43556")).to be true
+      expect(@dec.send(:true_key?, "41521")).to be true
+      expect(@dec.send(:true_key?, "12345")).to be true
+    end
+
+    it "should return false for invalid keys" do
+      expect(@dec.send(:true_key?, "abcde")).to be false
+      expect(@dec.send(:true_key?, "41526a")).to be false
+      expect(@dec.send(:true_key?, "4152")).to be false
+      expect(@dec.send(:true_key?, "415216")).to be false
+    end
+  end
+
+  describe "#true_date?" do
+    it "should be a private method" do
+      expect{ @dec.true_date?(2) }.to raise_error(NoMethodError)
+    end
+
+    it "should take one compulsory argument" do
+      expect{ @dec.send(:true_date?) }.to raise_error(ArgumentError)
+      expect{ @dec.send(:true_date?, 123456, 90919) }.to raise_error(ArgumentError)
+    end
+
+    it "should return true for valid dates" do
+      expect(@dec.send(:true_date?, 11015)).to be true
+      expect(@dec.send(:true_date?, 81015)).to be true
+    end
+
+    it "should return false for invalid dates" do
+      expect(@dec.send(:true_date?, 110152)).to be false
+      expect(@dec.send(:true_date?, "hello")).to be false
+    end
+  end
+
+  describe "#Decrypt_file" do
+    it "should be a private method" do
+      expect{ @dec.Decrypt_file }.to raise_error (NoMethodError)
+    end
+
+    it "should take four arguments" do
+      expect { @dec.send(:decrypt_file) }.to raise_error(ArgumentError)
+      expect { @dec.send(:decrypt_file, "message.txt") }.to raise_error(ArgumentError)
+      expect { @dec.send(:decrypt_file, "message.txt", "enc.txt") }.to raise_error(ArgumentError)
+      expect { @dec.send(:decrypt_file, "message.txt", "enc.txt", 24515) }.to raise_error(ArgumentError)
+    end
+
+    it "should display a success message if file was successfully created" do
+      
+      io = double("io", puts: nil)
+      message = Gemnigma::Messages.new(io)
+      message.success_message("file.txt", "94704", "81015")
+
+      expect(io).to have_received(:puts).with("\n........................................................")
+      expect(io).to have_received(:puts).with("\nCreated 'file.txt' with secret key 94704 and date 81015")
+    end
+  end
+end

data/spec/encrypt_spec.rb

@@ -0,0 +1,61 @@
+require_relative "spec_helper"
+
+describe Gemnigma::Encrypt do
+  before :each do
+    @enc = Gemnigma::Encrypt.new
+  end
+
+  it "should be a subclass of RotatorEncrypt" do
+    expect(Gemnigma::Encrypt.superclass).to eql(Gemnigma::RotatorEncrypt)
+  end
+
+  it "should be an instance of the class Encrypt" do
+    expect(@enc).to be_an_instance_of Gemnigma::Encrypt
+  end
+
+  describe "#get_cmd_args" do
+    it "should take no arguments" do
+      expect{ @enc.get_cmd_args(123) }.to raise_error(ArgumentError)
+    end
+
+    it "should display an error message if few arguments are passed as command line arguments" do
+
+      io = double("io", puts: nil)
+      message = Gemnigma::Messages.new(io)
+      message.few_args
+
+      expect(io).to have_received(:puts).with("Not enough arguments passed in. Run Gemnigma --help for instructions on usage\nExiting...")
+    end
+
+    it "should display an error message if too many arguments are passed as command line arguments" do
+
+      io = double("io", puts: nil)
+      message = Gemnigma::Messages.new(io)
+      message.too_much_args
+
+      expect(io).to have_received(:puts).with("Too many arguments passed in. Run Gemnigma --help for instructions on usage\nExiting...")
+    end
+  end
+
+  describe "#encrypt_file" do
+    it "should be a private method" do
+      expect{ @enc.encrypt_file }.to raise_error (NoMethodError)
+    end
+
+    it "should take two arguments" do
+      expect { @enc.send(:encrypt_file) }.to raise_error(ArgumentError)
+      expect { @enc.send(:encrypt_file, "message.txt") }.to raise_error(ArgumentError)
+      expect { @enc.send(:encrypt_file, "message.txt", "file.txt", "io.txt") }.to raise_error(ArgumentError)
+    end
+
+    it "should display a success message if file was successfully created" do
+      
+      io = double("io", puts: nil)
+      message = Gemnigma::Messages.new(io)
+      message.success_message("file.txt", "94704", "81015")
+
+      expect(io).to have_received(:puts).with("\n........................................................")
+      expect(io).to have_received(:puts).with("\nCreated 'file.txt' with secret key 94704 and date 81015")
+    end
+  end
+end

data/spec/key_spec.rb

@@ -0,0 +1,48 @@
+require_relative "spec_helper"
+
+describe Gemnigma::Key do
+  before :each do
+    @key = Gemnigma::Key.new(41521)
+  end
+
+  it "should return Key as it's class name" do
+    expect(@key).to be_an_instance_of Gemnigma::Key
+  end
+
+  describe "#initialize" do
+    context "when called with parameter" do
+      it "should initialize a new instance with the specified key" do
+        key = Gemnigma::Key.new(12345)
+        expect(key.key).to eql(12345)
+      end
+    end
+
+    context "when called without parameter" do
+      it "should default to 41521 if no key is specified" do
+        key = Gemnigma::Key.new
+        expect(key.key).to eql(41521)
+      end 
+    end
+
+    context "when called with wrong parameter value" do
+      it "should default to 41521 if key is invalid" do
+        key = Gemnigma::Key.new("12345")
+        expect(key.key).to eql(41521)
+      end
+    end
+  end
+
+  describe "#key_map" do
+    it "should return an array when called" do
+      expect(@key.key_map.class).to eql(Array)
+    end
+
+    it "should return an array with a length of 4" do
+      expect(@key.key_map.length).to eql(4)
+    end
+
+    it "should return an array of consecutive numbers based on the key" do
+      expect(@key.key_map).to eql([41, 15, 52, 21])
+    end
+  end
+end

data/spec/messages_spec.rb

@@ -0,0 +1,161 @@
+require_relative "spec_helper"
+
+describe Gemnigma::Messages do
+  before :each do
+    @msg = Gemnigma::Messages.new
+  end
+
+  it "should be an instance of the Messages class" do
+    expect(@msg).to be_an_instance_of Gemnigma::Messages
+  end
+
+  describe "#initialize" do
+    it "should default to standard output as the default if no argument is supplied to new" do
+      is_stdout = (@msg.instance_variable_get(:@io) == STDOUT)
+      expect(is_stdout).to be true
+    end
+
+    it "should take whatever argument is passed into it as the output stream" do
+      msg = Gemnigma::Messages.new(StringIO.new)
+      expect(msg.instance_variable_get(:@io).class).to eql(StringIO)
+    end
+  end
+
+  describe "#puts" do
+    it "should take one compulsory argument" do
+      expect{ @msg.puts }.to raise_error(ArgumentError)
+      expect{ @msg.puts("hello", "world") }.to raise_error(ArgumentError)
+    end
+
+    it "should print to the console whatever is passed into it" do
+      
+      io = double("io", puts: nil)
+      msg = Gemnigma::Messages.new(io)
+      msg.puts "Hello World"
+      msg.puts("This is a ridiculously long message")
+
+      expect(io).to have_received(:puts).with("Hello World")
+      expect(io).to have_received(:puts).with("This is a ridiculously long message")
+    end
+  end
+
+  describe "#few_args" do
+    it "should print to the console when few_args is called" do
+         
+      io = double("io", puts: nil)
+      msg = Gemnigma::Messages.new(io)
+      msg.few_args
+
+      expect(io).to have_received(:puts).with("Not enough arguments passed in. Run Gemnigma --help for instructions on usage\nExiting...")
+    end
+  end
+
+  describe "#too_much_args" do
+    it "should print to the console when too_much_args is called" do
+
+      io = double("io", puts: nil)
+      msg = Gemnigma::Messages.new(io)
+      msg.too_much_args
+
+      expect(io).to have_received(:puts).with("Too many arguments passed in. Run Gemnigma --help for instructions on usage\nExiting...")
+    end
+  end
+
+  describe "#file_not_in_existence" do
+    it "should take one compulsory argument" do
+      expect{ @msg.file_not_in_existence }.to raise_error(ArgumentError)
+      expect{ @msg.file_not_in_existence("file", "new_file") }.to raise_error(ArgumentError)
+    end
+    
+    it "should print to the console when file_not_in_existence is called" do
+      
+      io = double("io", puts: nil)
+      msg = Gemnigma::Messages.new(io)
+      msg.file_not_in_existence("file.txt")
+
+      expect(io).to have_received(:puts).with("file.txt: File does not exist\nExiting...")
+    end
+  end
+
+  describe "#file_in_existence" do
+    it "should take two compulsory argument" do
+      expect{ @msg.file_in_existence }.to raise_error(ArgumentError)
+      expect{ @msg.file_in_existence("file", "new_file", "another_file") }.to raise_error(ArgumentError)
+    end
+    
+    it "should print to the console when file_in_existence is called" do
+      
+      io = double("io", puts: nil)
+      msg = Gemnigma::Messages.new(io)
+      msg.file_in_existence("file.txt", "new_file.txt")
+
+      expect(io).to have_received(:puts).with("file.txt exists... Checking new_file.txt")
+    end
+  end
+
+  describe "#creating_new_file" do
+    it "should take one compulsory argument" do
+      expect{ @msg.creating_new_file }.to raise_error(ArgumentError)
+      expect{ @msg.creating_new_file("file", "new_file") }.to raise_error(ArgumentError)
+    end
+    
+    it "should print to the console when creating_new_file is called" do
+      
+      io = double("io", puts: nil)
+      msg = Gemnigma::Messages.new(io)
+      msg.creating_new_file("file.txt")
+
+      expect(io).to have_received(:puts).with("file.txt will be created, proceeding...")
+    end
+  end
+
+  describe "#overwrite_warning" do
+    it "should take one compulsory argument" do
+      expect{ @msg.overwrite_warning }.to raise_error(ArgumentError)
+      expect{ @msg.overwrite_warning("file", "new_file") }.to raise_error(ArgumentError)
+    end
+    
+    it "should print to the console when overwrite_warning is called" do
+      
+      io = double("io", puts: nil)
+      msg = Gemnigma::Messages.new(io)
+      msg.overwrite_warning("file.txt")
+
+      expect(io).to have_received(:puts).with( "file.txt exists already, do you want to overwrite it? (Y) or (N): ")
+    end
+  end
+
+  describe "#wrong_date" do
+     it "should take one compulsory argument" do
+      expect{ @msg.wrong_date }.to raise_error(ArgumentError)
+      expect{ @msg.wrong_date("12345", "09190002") }.to raise_error(ArgumentError)
+    end
+
+    it "should print to the console when wrong_date is called" do
+
+      io = double("io", puts: nil)
+      msg = Gemnigma::Messages.new(io)
+      msg.wrong_date("abcde")
+
+      expect(io).to have_received(:puts).with("abcde doesn't match the specified date format\nExiting...")
+    end
+  end
+
+  describe "#success_message" do
+    it "should take three compulsory arguments" do
+      expect{ @msg.success_message }.to raise_error(ArgumentError)
+      expect{ @msg.success_message("file.txt", "new.txt") }.to raise_error(ArgumentError)
+      expect{ @msg.success_message("file.txt", "new.txt", "810", "105") }.to raise_error(ArgumentError)
+    end
+
+    it "should print to the console when success_message is called" do
+      
+      io = double("io", puts: nil)
+      msg = Gemnigma::Messages.new(io)
+      msg.success_message("new.txt", "94704", "81015")
+
+      expect(io).to have_received(:puts).with("\n........................................................")
+      expect(io).to have_received(:puts).with("\nCreated 'new.txt' with secret key 94704 and date 81015")
+    end
+  end
+end

data/spec/offset_spec.rb

@@ -0,0 +1,62 @@
+require_relative "spec_helper"
+
+describe Gemnigma::Offset do
+  before :each do 
+    @offset = Gemnigma::Offset.new
+  end
+
+  it "should return Offset as it's class name" do
+    expect(@offset).to be_an_instance_of Gemnigma::Offset
+  end
+
+  describe "#date" do
+    it "should return the current date" do
+      expect(@offset.date.asctime).to eql(Time.now.asctime)
+    end
+  end
+
+  describe "#formatted_date" do
+    it "should be a private method" do
+      expect { @offset.formatted_date }.to raise_error(NoMethodError)
+    end
+
+    it "should return a formatted date in the format ddmmyy" do
+      expect(@offset.send(:formatted_date).to_s).to match(/\d\d\d\d\d/)
+    end
+  end
+
+  describe "#squared_date" do
+    it "should be a private method" do
+      expect { @offset.squared_date }.to raise_error(NoMethodError)
+    end
+
+    it "should return the square of the formatted_date" do
+      square = @offset.send(:formatted_date) ** 2
+      expect(@offset.send(:squared_date)).to eql(square)
+    end
+  end
+
+  describe "#offset" do
+    it "should return an array" do
+      expect(@offset.offset.class).to eql(Array)
+    end
+
+    it "should return an array with a length of 4" do
+      expect(@offset.offset.length).to eql(4)
+    end
+
+    it "should return an array of integers" do
+      expect(@offset.offset.all? {|offset| offset.class == Fixnum}).to be true
+    end
+  end
+
+  describe "#full_date" do
+    it "should return an integer" do
+      expect(@offset.full_date.is_a? Integer).to be true
+    end
+
+    it "should return an integer corresponding to date the offset is based upon" do
+      expect(@offset.full_date.to_s).to match(/\d\d\d\d\d/)
+    end
+  end
+end

data/spec/rotator_decrypt_spec.rb

@@ -0,0 +1,21 @@
+require_relative "spec_helper"
+
+describe Gemnigma::RotatorDecrypt do
+  before :each do
+    @rot_dec = Gemnigma::RotatorDecrypt.new
+  end
+
+  it "should be a subclass of RotatorEncrypt" do
+    expect(Gemnigma::RotatorDecrypt.superclass).to eql(Gemnigma::RotatorEncrypt)
+  end
+
+  describe "#rot_decrypt" do
+    it "should take one parameter" do
+      expect{ @rot_dec.rot_decrypt }.to raise_error(ArgumentError)
+    end
+
+    it "should return a new string" do
+      expect(@rot_dec.rot_decrypt("qv0.x")).not_to eql("qv0.x")
+    end
+  end
+end

data/spec/rotator_encrypt_spec.rb

@@ -0,0 +1,130 @@
+require_relative "spec_helper"
+
+describe Gemnigma::RotatorEncrypt do
+  before :each do
+    @rot_enc = Gemnigma::RotatorEncrypt.new
+  end
+
+  describe "#initialize" do
+    context "with one optionally defined parameter" do
+      it "should return an instance of RotatorEncrypt" do
+        rot = Gemnigma::RotatorEncrypt.new(Gemnigma::Key.new)
+        expect(rot).to be_an_instance_of Gemnigma::RotatorEncrypt
+      end
+
+      it "should default to 41521 if an invalid key is used for initialization" do
+        rot = Gemnigma::RotatorEncrypt.new(21345)
+        expect(rot.key_map).to eql([41, 15, 52, 21])
+      end
+    end
+
+    context "without parameters" do
+      it "should return an instance of RotatorEncrypt" do
+        expect(@rot_enc).to be_an_instance_of Gemnigma::RotatorEncrypt
+      end
+
+      it "should default to 41521 as the key map" do
+        expect(@rot_enc.key_map).to eql([41, 15, 52, 21])
+      end
+    end
+  end
+
+  describe "#char_rotation" do
+    it "should be a private method" do
+      expect{ @rot_enc.char_rotation }.to raise_error(NoMethodError)
+    end
+
+    it "should exist as a method of the class RotatorEncrypt" do
+      expect(@rot_enc.private_methods.include? :char_rotation).to be true
+    end
+
+    it "should return an array" do
+      expect(@rot_enc.send(:char_rotation).class).to eql(Array)
+    end
+
+    it "should return an array with a length of 4" do
+      expect(@rot_enc.send(:char_rotation).length).to eql(4)
+    end
+
+    it "should return an array of numbers" do
+      expect(@rot_enc.send(:char_rotation).all? {|num| num.is_a? Integer}).to be true
+    end
+  end
+
+  describe "#map_word_to_key" do
+    it "should be a private method" do
+      expect{ @rot_enc.map_word_to_key }.to raise_error(NoMethodError)
+    end
+
+    it "should take one parameter" do
+      expect{ @rot_enc.send(:map_word_to_key) }.to raise_error(ArgumentError)
+      expect{ @rot_enc.send(:map_word_to_key, "hello", "world") }.to raise_error(ArgumentError)
+    end
+
+    it "should return an array" do
+      expect(@rot_enc.send(:map_word_to_key, "Hello").class).to eql(Array)
+    end
+
+    it "should return an array of arrays" do
+      expect(@rot_enc.send(:map_word_to_key, "Hello").all? {|item| item.is_a? Array}).to be true
+    end
+
+    it "should return an array of arrays containing a string and a number" do
+      result = @rot_enc.send(:map_word_to_key, "Hello").map do |arr|
+        arr.all? {|item| item.class == String || item.class == Fixnum}
+      end
+      expect(result.all?).to be true
+    end
+
+    it "should return an array length based on passed in word" do
+      expect(@rot_enc.send(:map_word_to_key, "H").length).to eql(1)
+      expect(@rot_enc.send(:map_word_to_key, "He").length).to eql(2)
+      expect(@rot_enc.send(:map_word_to_key, "Hel").length).to eql(3)
+      expect(@rot_enc.send(:map_word_to_key, "Hell").length).to eql(4)
+      expect(@rot_enc.send(:map_word_to_key, "Hello").length).to eql(5)
+    end
+  end
+
+  describe "#rot_encrypt" do
+    it "should take one parameter" do
+      expect{ @rot_enc.rot_encrypt }.to raise_error(ArgumentError)
+    end
+
+    it "should return a new string" do
+      expect(@rot_enc.rot_encrypt("hello")).not_to eql("hello")
+    end
+  end
+
+  describe "#get_offset" do
+    it "should be a private method" do
+      expect{ @rot_enc.get_offset }.to raise_error(NoMethodError)
+    end
+
+    it "should return an array" do
+      expect(@rot_enc.send(:get_offset)).to be_an(Array)
+    end
+
+    it "should return an array of integers" do
+      expect(@rot_enc.send(:get_offset).all? {|item| item.class == Fixnum }).to be true
+    end
+  end
+
+  describe "#map_key_to_offset" do
+    it "should be a private method" do
+      expect{ @rot_enc.map_key_to_offset }.to raise_error(NoMethodError)
+    end
+
+    it "should return an array" do
+      expect(@rot_enc.send(:map_key_to_offset)).to be_an(Array)
+    end
+
+    it "should return an array with four items" do
+      expect(@rot_enc.send(:map_key_to_offset).length).to eql(4)
+    end
+
+    it "should return a nested array" do
+      expect(@rot_enc.send(:map_key_to_offset).all? {|item| item.class == Array }).to be true
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+require "coveralls"
+Coveralls.wear!
+
+require_relative "../helpers/char_map"
+require_relative "../helpers/cipher_encrypt"
+require_relative "../helpers/cipher_decrypt"
+require_relative "../helpers/key"
+require_relative "../helpers/offset"
+require_relative "../helpers/rotator_encrypt"
+require_relative "../helpers/rotator_decrypt"
+require_relative "../helpers/validate_file_arg"
+require_relative "../helpers/messages"
+require_relative "../lib/Gemnigma/encrypt"
+require_relative "../lib/Gemnigma/decrypt"
+require_relative "../lib/Gemnigma/crack"
+require_relative "../lib/Gemnigma/version"
+require_relative "../lib/Gemnigma.rb"

data/spec/validate_file_arg_spec.rb

@@ -0,0 +1,49 @@
+require_relative "spec_helper"
+
+describe Gemnigma::ValidateFileArg do
+  it "should be a module" do
+    expect(Gemnigma::ValidateFileArg.class).to eql(Module)
+  end
+
+  it "should have a method validate" do
+    expect(Gemnigma::ValidateFileArg.instance_methods.include? :validate).to be true
+  end
+
+  describe "#validate" do
+    it "should display an error message if input file does not exist" do
+
+      io = double("io", puts: nil)
+      message = Gemnigma::Messages.new(io)
+      message.file_not_in_existence("non-existent.txt")
+
+      expect(io).to have_received(:puts).with("non-existent.txt: File does not exist\nExiting...")
+    end
+
+    it "should display a success message if file exists" do
+
+      io = double("io", puts: nil)
+      message = Gemnigma::Messages.new(io)
+      message.file_in_existence("message.txt", "new_file.txt")
+
+      expect(io).to have_received(:puts).with("message.txt exists... Checking new_file.txt")
+    end
+
+    it "should display a informing a user that a file is about to be created" do
+
+      io = double("io", puts: nil)
+      message = Gemnigma::Messages.new(io)
+      message.creating_new_file("new_file.txt")
+
+      expect(io).to have_received(:puts).with("new_file.txt will be created, proceeding...")
+    end
+
+    it "should display a message alerting a user that a file is already in existence" do
+
+      io = double("io", puts: nil)
+      message = Gemnigma::Messages.new(io)
+      message.overwrite_warning("new_file.txt")
+
+      expect(io).to have_received(:puts).with("new_file.txt exists already, do you want to overwrite it? (Y) or (N): ")
+    end
+  end
+end

data/spec/version_spec.rb

@@ -0,0 +1,11 @@
+require_relative "spec_helper"
+
+describe "version.rb" do
+  it "should be a constant" do
+    expect(Gemnigma.constants.include? :VERSION).to be true
+  end
+
+  it "should return a string as it's value" do
+    expect(Gemnigma::VERSION.class).to eql(String)
+  end
+end