win32-taskscheduler 0.3.2 → 0.4.0

data/lib/win32/windows/constants.rb

@@ -0,0 +1,260 @@
+module Windows
+  module TaskSchedulerConstants
+
+    SYSTEM_USERS = ['NT AUTHORITY\SYSTEM', "SYSTEM", 'NT AUTHORITY\LOCALSERVICE', 'NT AUTHORITY\NETWORKSERVICE', 'BUILTIN\USERS', "USERS"].freeze
+
+    # Triggers
+
+    # Trigger is set to run the task a single time
+    TASK_TIME_TRIGGER_ONCE = 1
+
+    # Trigger is set to run the task on a daily interval
+    TASK_TIME_TRIGGER_DAILY = 2
+
+    # Trigger is set to run the task on specific days of a specific week & month
+    TASK_TIME_TRIGGER_WEEKLY = 3
+
+    # Trigger is set to run the task on specific day(s) of the month
+    TASK_TIME_TRIGGER_MONTHLYDATE = 4
+
+    # Trigger is set to run the task on specific day(s) of the month
+    TASK_TIME_TRIGGER_MONTHLYDOW = 5
+
+    # Trigger is set to run the task if the system remains idle for the amount
+    # of time specified by the idle wait time of the task
+    TASK_EVENT_TRIGGER_ON_IDLE = 6
+
+    TASK_TRIGGER_REGISTRATION = 7
+
+    # Trigger is set to run the task at system startup
+    TASK_EVENT_TRIGGER_AT_SYSTEMSTART = 8
+
+    # Trigger is set to run the task when a user logs on
+    TASK_EVENT_TRIGGER_AT_LOGON = 9
+
+    TASK_TRIGGER_SESSION_STATE_CHANGE = 11
+
+    # Daily Tasks
+
+    # The task will run on Sunday
+    TASK_SUNDAY = 0x1
+
+    # The task will run on Monday
+    TASK_MONDAY = 0x2
+
+    # The task will run on Tuesday
+    TASK_TUESDAY = 0x4
+
+    # The task will run on Wednesday
+    TASK_WEDNESDAY = 0x8
+
+    # The task will run on Thursday
+    TASK_THURSDAY = 0x10
+
+    # The task will run on Friday
+    TASK_FRIDAY = 0x20
+
+    # The task will run on Saturday
+    TASK_SATURDAY = 0x40
+
+    # Weekly tasks
+
+    # The task will run between the 1st and 7th day of the month
+    TASK_FIRST_WEEK = 0x01
+
+    # The task will run between the 8th and 14th day of the month
+    TASK_SECOND_WEEK = 0x02
+
+    # The task will run between the 15th and 21st day of the month
+    TASK_THIRD_WEEK = 0x04
+
+    # The task will run between the 22nd and 28th day of the month
+    TASK_FOURTH_WEEK = 0x08
+
+    # The task will run the last seven days of the month
+    TASK_LAST_WEEK = 0x10
+
+    # Monthly tasks
+
+    # The task will run in January
+    TASK_JANUARY = 0x1
+
+    # The task will run in February
+    TASK_FEBRUARY = 0x2
+
+    # The task will run in March
+    TASK_MARCH = 0x4
+
+    # The task will run in April
+    TASK_APRIL = 0x8
+
+    # The task will run in May
+    TASK_MAY = 0x10
+
+    # The task will run in June
+    TASK_JUNE = 0x20
+
+    # The task will run in July
+    TASK_JULY = 0x40
+
+    # The task will run in August
+    TASK_AUGUST = 0x80
+
+    # The task will run in September
+    TASK_SEPTEMBER = 0x100
+
+    # The task will run in October
+    TASK_OCTOBER = 0x200
+
+    # The task will run in November
+    TASK_NOVEMBER = 0x400
+
+    # The task will run in December
+    TASK_DECEMBER = 0x800
+
+    # Flags
+
+    # Used when converting AT service jobs into work items
+    TASK_FLAG_INTERACTIVE = 0x1
+
+    # The work item will be deleted when there are no more scheduled run times
+    TASK_FLAG_DELETE_WHEN_DONE = 0x2
+
+    # The work item is disabled. Useful for temporarily disabling a task
+    TASK_FLAG_DISABLED = 0x4
+
+    # The work item begins only if the computer is not in use at the scheduled
+    # start time
+    TASK_FLAG_START_ONLY_IF_IDLE = 0x10
+
+    # The work item terminates if the computer makes an idle to non-idle
+    # transition while the work item is running
+    TASK_FLAG_KILL_ON_IDLE_END = 0x20
+
+    # The work item does not start if the computer is running on battery power
+    TASK_FLAG_DONT_START_IF_ON_BATTERIES = 0x40
+
+    # The work item ends, and the associated application quits, if the computer
+    # switches to battery power
+    TASK_FLAG_KILL_IF_GOING_ON_BATTERIES = 0x80
+
+    # The work item starts only if the computer is in a docking station
+    TASK_FLAG_RUN_ONLY_IF_DOCKED = 0x100
+
+    # The work item created will be hidden
+    TASK_FLAG_HIDDEN = 0x200
+
+    # The work item runs only if there is a valid internet connection
+    TASK_FLAG_RUN_IF_CONNECTED_TO_INTERNET = 0x400
+
+    # The work item starts again if the computer makes a non-idle to idle
+    # transition
+    TASK_FLAG_RESTART_ON_IDLE_RESUME = 0x800
+
+    # The work item causes the system to be resumed, or awakened, if the
+    # system is running on batter power
+    TASK_FLAG_SYSTEM_REQUIRED = 0x1000
+
+    # The work item runs only if a specified account is logged on interactively
+    TASK_FLAG_RUN_ONLY_IF_LOGGED_ON = 0x2000
+
+    # Triggers
+
+    # The task will stop at some point in time
+    TASK_TRIGGER_FLAG_HAS_END_DATE = 0x1
+
+    # The task can be stopped at the end of the repetition period
+    TASK_TRIGGER_FLAG_KILL_AT_DURATION_END = 0x2
+
+    # The task trigger is disabled
+    TASK_TRIGGER_FLAG_DISABLED = 0x4
+
+    # Run Level Types
+    # Tasks will be run with the least privileges
+    TASK_RUNLEVEL_LUA      = 0
+    # Tasks will be run with the highest privileges
+    TASK_RUNLEVEL_HIGHEST  = 1
+
+    # Logon Types
+    # Used for non-NT credentials
+    TASK_LOGON_NONE                           = 0
+    # Use a password for logging on the user
+    TASK_LOGON_PASSWORD                       = 1
+    # The service will log the user on using Service For User
+    TASK_LOGON_S4U                            = 2
+    # Task will be run only in an existing interactive session
+    TASK_LOGON_INTERACTIVE_TOKEN              = 3
+    # Group activation. The groupId field specifies the group
+    TASK_LOGON_GROUP                          = 4
+    # When Local System, Local Service, or Network Service account is
+    # being used as a security context to run the task
+    TASK_LOGON_SERVICE_ACCOUNT                = 5
+    # Not in use; currently identical to TASK_LOGON_PASSWORD
+    TASK_LOGON_INTERACTIVE_TOKEN_OR_PASSWORD  = 6
+
+
+    TASK_MAX_RUN_TIMES = 1440
+    TASKS_TO_RETRIEVE  = 5
+
+    # Task creation
+
+    TASK_VALIDATE_ONLY = 0x1
+    TASK_CREATE = 0x2
+    TASK_UPDATE = 0x4
+    TASK_CREATE_OR_UPDATE = 0x6
+    TASK_DISABLE = 0x8
+    TASK_DONT_ADD_PRINCIPAL_ACE = 0x10
+    TASK_IGNORE_REGISTRATION_TRIGGERS = 0x20
+
+    # Priority classes
+
+    REALTIME_PRIORITY_CLASS     = 0
+    HIGH_PRIORITY_CLASS         = 1
+    ABOVE_NORMAL_PRIORITY_CLASS = 2 # Or 3
+    NORMAL_PRIORITY_CLASS       = 4 # Or 5, 6
+    BELOW_NORMAL_PRIORITY_CLASS = 7 # Or 8
+    IDLE_PRIORITY_CLASS         = 9 # Or 10
+
+    CLSCTX_INPROC_SERVER  = 0x1
+    CLSID_CTask =  [0x148BD520,0xA2AB,0x11CE,0xB1,0x1F,0x00,0xAA,0x00,0x53,0x05,0x03].pack('LSSC8')
+    CLSID_CTaskScheduler =  [0x148BD52A,0xA2AB,0x11CE,0xB1,0x1F,0x00,0xAA,0x00,0x53,0x05,0x03].pack('LSSC8')
+    IID_ITaskScheduler = [0x148BD527,0xA2AB,0x11CE,0xB1,0x1F,0x00,0xAA,0x00,0x53,0x05,0x03].pack('LSSC8')
+    IID_ITask = [0x148BD524,0xA2AB,0x11CE,0xB1,0x1F,0x00,0xAA,0x00,0x53,0x05,0x03].pack('LSSC8')
+    IID_IPersistFile = [0x0000010b,0x0000,0x0000,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46].pack('LSSC8')
+
+    # Days of month
+
+    TASK_FIRST = 0x01
+    TASK_SECOND = 0x02
+    TASK_THIRD = 0x04
+    TASK_FOURTH = 0x08
+    TASK_FIFTH = 0x10
+    TASK_SIXTH = 0x20
+    TASK_SEVENTH = 0x40
+    TASK_EIGHTH = 0x80
+    TASK_NINETH = 0x100
+    TASK_TENTH = 0x200
+    TASK_ELEVENTH = 0x400
+    TASK_TWELFTH = 0x800
+    TASK_THIRTEENTH = 0x1000
+    TASK_FOURTEENTH = 0x2000
+    TASK_FIFTEENTH = 0x4000
+    TASK_SIXTEENTH = 0x8000
+    TASK_SEVENTEENTH = 0x10000
+    TASK_EIGHTEENTH = 0x20000
+    TASK_NINETEENTH = 0x40000
+    TASK_TWENTIETH = 0x80000
+    TASK_TWENTY_FIRST = 0x100000
+    TASK_TWENTY_SECOND = 0x200000
+    TASK_TWENTY_THIRD = 0x400000
+    TASK_TWENTY_FOURTH = 0x800000
+    TASK_TWENTY_FIFTH = 0x1000000
+    TASK_TWENTY_SIXTH = 0x2000000
+    TASK_TWENTY_SEVENTH = 0x4000000
+    TASK_TWENTY_EIGHTH = 0x8000000
+    TASK_TWENTY_NINTH = 0x10000000
+    TASK_THIRTYETH = 0x20000000
+    TASK_THIRTY_FIRST = 0x40000000
+    TASK_LAST = 0x80000000
+  end
+end

data/lib/win32/windows/time_calc_helper.rb

@@ -0,0 +1,130 @@
+module Windows
+  module TimeCalcHelper
+
+    # Returns actual no of days for given month;
+    # Array with a 0 is defined to give actual result without
+    # any manipulation. eg, DAYS_IN_A_MONTH[1] = 31
+    # 0(NUMBER) is kept to avoid exceptions during calculations
+    DAYS_IN_A_MONTH = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+
+    # Returns no of days in a given month of a year
+    def days_in_month(month, year)
+      (month == 2 && is_leap_year?(year)) ? 29 : DAYS_IN_A_MONTH[month]
+    end
+
+    # Year is leap when it is a multiple of 4 and not a multiple of 100.
+    # But it can be a multiple of 400
+    def is_leap_year?(year)
+      (((year % 4).zero? && !(year % 100).zero?) || (year % 400).zero?)
+    end
+
+    # Returns total time duration in minutes
+    def time_in_minutes(time_str)
+      time_in_seconds(time_str) / 60
+    end
+
+    # Calculates total time duration in seconds
+    def time_in_seconds(time_str)
+      dt_tm_hash = time_details(time_str)
+      curr_time = Time.now
+
+      # Basic time variables
+      future_year = curr_time.year + dt_tm_hash[:year].to_i
+      future_month = curr_time.month + dt_tm_hash[:month].to_i
+      future_day = curr_time.day + dt_tm_hash[:day].to_i
+      future_hr = curr_time.hour + dt_tm_hash[:hour].to_i
+      future_min = curr_time.min + dt_tm_hash[:min].to_i
+      future_sec = curr_time.sec + dt_tm_hash[:sec].to_i
+
+      # 'extra value' calculations for these time variables
+      future_sec, future_min = extra_time(future_sec, future_min, 60)
+      future_min, future_hr = extra_time(future_min, future_hr, 60)
+      future_hr, future_day = extra_time(future_hr, future_day, 24)
+
+      # explicit method to calculate overloaded days;
+      # They may stretch upto years; heance leap year & months are into consideration
+      future_day, future_month, future_year = extra_days(future_day, future_month, future_year, curr_time.month, curr_time.year)
+
+      future_month, future_year = extra_months(future_month, future_year, curr_time.month, curr_time.year)
+
+      future_time = Time.new(future_year, future_month, future_day, future_hr, future_min, future_sec)
+
+      # Difference in time will return seconds
+      future_time.to_i - curr_time.to_i
+    end
+
+    # a will contain extra value of low_rank (in high_rank(eg min));
+    # b will hold actual low_rank value(ie sec) Example:
+    # low_rank = 65, high_rank = 2, div_val = 60
+    # Hence a = 1; b = 5
+    def extra_time(low_rank, high_rank, div_val)
+      a, b = low_rank.divmod(div_val)
+      high_rank += a; low_rank = b
+      [low_rank, high_rank]
+    end
+
+    def extra_months(month_count, year_count, init_month, init_year)
+      year, month_count = month_count.divmod(12)
+      if year.positive? && month_count.zero?
+        month_count = 12
+        year -= 1
+      end
+      year_count += year
+      [month_count, year_count]
+    end
+
+    # Returns no of actual days with all overloaded months & Years
+    def extra_days(days_count, month_count, year_count, init_month, init_year)
+      # Will keep increamenting them with surplus days
+      days = days_count
+      mth = init_month
+      yr = init_year
+
+      loop do
+       days -= days_in_month(mth, yr)
+       break if days <= 0
+       mth += 1
+       if mth > 12
+         mth = 1; yr += 1
+       end
+       days_count = days
+      end
+
+      # Setting actual incremented values
+      month_count += (mth - init_month)
+      year_count += (yr - init_year)
+
+      [days_count, month_count, year_count]
+    end
+
+    # Extracts "P_Y_M_DT_H_M_S" format and
+    # Returns a hash with applicable values of
+    # (keys =>) [:year, :month, :day, :hour, :min, :sec]
+    # Example: "PT3S" => {sec: 3}
+    def time_details(time_str)
+      tm_detail = {}
+      if time_str.to_s != ''
+        # time_str will be like "PxxYxxMxxDTxxHxxMxxS"
+        # Ignoring 'P' and extracting date and time
+        dt, tm = time_str[1..-1].split('T')
+
+        # Replacing strings
+        if dt.to_s != ''
+          dt['Y'] = 'year' if dt['Y']; dt['M'] = 'month' if dt['M']; dt['D'] = 'day' if dt['D']
+          dt_tm_array_to_hash(dt, tm_detail)
+        end
+
+        if tm.to_s != ''
+          tm['H'] = 'hour' if tm['H']; tm['M'] = 'min' if tm['M']; tm['S'] = 'sec' if tm['S']
+          dt_tm_array_to_hash(tm, tm_detail)
+        end
+      end
+      tm_detail
+    end
+
+    # Method to convert date/time array to hash
+    def dt_tm_array_to_hash(arr, tm_detail)
+      arr.split(/(\d+)/)[1..-1].each_slice(2).inject(tm_detail) { |h, i| h[i.last.to_sym] = i.first; h }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+$LOAD_PATH.unshift File.expand_path('../lib/win32', __dir__)

data/spec/win32/windows/time_calc_helper_spec.rb

@@ -0,0 +1,392 @@
+require 'win32/windows/time_calc_helper'
+require 'spec_helper'
+
+RSpec.describe Windows::TimeCalcHelper do
+  let(:object) { klass.new }
+  let(:klass) do
+    Class.new do
+      include Windows::TimeCalcHelper
+    end
+  end
+
+  describe 'Format Test:' do
+    context 'An Invalid Date-Time string' do
+      time_str = 'An Invalid String'
+      let(:time_details) { object.time_details(time_str) }
+      it 'Returns an empty hash' do
+        expect(time_details).to be_a(Hash)
+        expect(time_details).to be_empty
+      end
+    end
+
+    context 'A valid Date string' do
+      time_str = 'P1Y2M3D'
+      let(:time_details) { object.time_details(time_str) }
+      it 'Returns a valid Hash with only Date values' do
+        expect(time_details).to be_a(Hash)
+        expect(time_details[:year]).to eql('1')
+        expect(time_details[:month]).to eql('2')
+        expect(time_details[:day]).to eql('3')
+        expect(time_details[:hour]).to be_nil
+        expect(time_details[:min]).to be_nil
+        expect(time_details[:sec]).to be_nil
+      end
+    end
+
+    context 'A valid Time string' do
+      time_str = 'PT4H5M6S'
+      let(:time_details) { object.time_details(time_str) }
+      it 'Returns a valid Hash with only Time values' do
+        expect(time_details).to be_a(Hash)
+        expect(time_details[:year]).to be_nil
+        expect(time_details[:month]).to be_nil
+        expect(time_details[:day]).to be_nil
+        expect(time_details[:hour]).to eql('4')
+        expect(time_details[:min]).to eql('5')
+        expect(time_details[:sec]).to eql('6')
+      end
+    end
+
+    context 'A valid Date-Time string' do
+      time_str = 'P1Y2M3DT4H5M6S'
+      let(:time_details) { object.time_details(time_str) }
+      it 'returns a valid Hash with values' do
+        expect(time_details).to be_a(Hash)
+        expect(time_details[:year]).to eql('1')
+        expect(time_details[:month]).to eql('2')
+        expect(time_details[:day]).to eql('3')
+        expect(time_details[:hour]).to eql('4')
+        expect(time_details[:min]).to eql('5')
+        expect(time_details[:sec]).to eql('6')
+      end
+    end
+
+    context 'An Unformatted Date-Time string' do
+      time_str = 'P2M3D1YT6S5M4H'
+      let(:time_details) { object.time_details(time_str) }
+      it 'Returns a valid Hash with values' do
+        expect(time_details).to be_a(Hash)
+        expect(time_details[:year]).to eql('1')
+        expect(time_details[:month]).to eql('2')
+        expect(time_details[:day]).to eql('3')
+        expect(time_details[:hour]).to eql('4')
+        expect(time_details[:min]).to eql('5')
+        expect(time_details[:sec]).to eql('6')
+      end
+    end
+
+    context 'A Date-Time string with few parameters' do
+      time_str = 'P1Y2MT3M4S'
+      let(:time_details) { object.time_details(time_str) }
+      it 'Returns a valid Hash with selected values' do
+        expect(time_details).to be_a(Hash)
+        expect(time_details[:year]).to eql('1')
+        expect(time_details[:month]).to eql('2')
+        expect(time_details[:day]).to be_nil
+        expect(time_details[:hour]).to be_nil
+        expect(time_details[:min]).to eql('3')
+        expect(time_details[:sec]).to eql('4')
+      end
+    end
+  end
+
+  describe 'Year conversion:' do
+    # Time.now to be a Non-Leap Year(0001-01-01 00:00:00), So that
+    # Tests suites will be independant of their execution Time
+    before(:each) do
+      allow(Time).to receive(:now).and_return(Time.new(1))
+    end
+
+    let(:current_time) { Time.new(1) }
+    context 'on given year' do
+      time_str = 'P1Y'
+      let(:time_seconds) { object.time_in_seconds(time_str) }
+      let(:next_time) { current_time + time_seconds }
+      it 'returns expected year' do
+        expect(next_time.year).to eql(current_time.year + 1)
+        expect(next_time.month).to eql(current_time.month)
+        expect(next_time.day).to eql(current_time.day)
+        expect(next_time.hour).to eql(current_time.hour)
+        expect(next_time.min).to eql(current_time.min)
+        expect(next_time.sec).to eql(current_time.sec)
+      end
+    end
+
+    context 'on given months' do
+      time_str = 'P12M'
+      let(:time_seconds) { object.time_in_seconds(time_str) }
+      let(:next_time) { current_time + time_seconds }
+      it 'returns expected year' do
+        expect(next_time.year).to eql(current_time.year + 1)
+        expect(next_time.month).to eql(current_time.month)
+        expect(next_time.day).to eql(current_time.day)
+        expect(next_time.hour).to eql(current_time.hour)
+        expect(next_time.min).to eql(current_time.min)
+        expect(next_time.sec).to eql(current_time.sec)
+      end
+    end
+
+    context 'on given days' do
+      time_str = 'P365D'
+      let(:time_seconds) { object.time_in_seconds(time_str) }
+      let(:next_time) { current_time + time_seconds }
+      it 'returns expected year' do
+        expect(next_time.year).to eql(current_time.year + 1)
+        expect(next_time.month).to eql(current_time.month)
+        expect(next_time.day).to eql(current_time.day)
+        expect(next_time.hour).to eql(current_time.hour)
+        expect(next_time.min).to eql(current_time.min)
+        expect(next_time.sec).to eql(current_time.sec)
+      end
+    end
+
+    context 'by given year and month' do
+      time_str = 'P1Y12M'
+      let(:time_seconds) { object.time_in_seconds(time_str) }
+      let(:next_time) { current_time + time_seconds }
+      it 'returns expected year' do
+        expect(next_time.year).to eql(current_time.year + 2)
+        expect(next_time.month).to eql(current_time.month)
+        expect(next_time.day).to eql(current_time.day)
+        expect(next_time.hour).to eql(current_time.hour)
+        expect(next_time.min).to eql(current_time.min)
+        expect(next_time.sec).to eql(current_time.sec)
+      end
+    end
+
+    context 'by given year, months and days' do
+      time_str = 'P1Y12M365D'
+      let(:time_seconds) { object.time_in_seconds(time_str) }
+      let(:next_time) { current_time + time_seconds }
+      it 'Returns the actual incremented day' do
+        expect(next_time.year).to eql(current_time.year + 3)
+        expect(next_time.month).to eql(current_time.month)
+        expect(next_time.day).to eql(current_time.day)
+        expect(next_time.hour).to eql(current_time.hour)
+        expect(next_time.min).to eql(current_time.min)
+        expect(next_time.sec).to eql(current_time.sec)
+      end
+    end
+  end
+
+  describe 'Month conversion:' do
+    # Time.now to be a Non-Leap Year(0001-01-01 00:00:00), So that
+    # Tests suites will be independant of their execution Time
+    before(:each) do
+      allow(Time).to receive(:now).and_return(Time.new(1))
+    end
+
+    let(:current_time) { Time.new(1) }
+    context 'on given month' do
+      time_str = 'P1M'
+      let(:time_seconds) { object.time_in_seconds(time_str) }
+      let(:next_time) { current_time + time_seconds }
+      it 'returns expected month' do
+        expect(next_time.year).to eql(current_time.year)
+        expect(next_time.month).to eql(current_time.month + 1)
+        expect(next_time.day).to eql(current_time.day)
+        expect(next_time.hour).to eql(current_time.hour)
+        expect(next_time.min).to eql(current_time.min)
+        expect(next_time.sec).to eql(current_time.sec)
+      end
+    end
+
+    context 'on given days' do
+      # Since we are running test on 1st month, next month will occur in 31 days
+      time_str = 'P31D'
+      let(:time_seconds) { object.time_in_seconds(time_str) }
+      let(:next_time) { current_time + time_seconds }
+      it 'returns expected month' do
+        expect(next_time.year).to eql(current_time.year)
+        expect(next_time.month).to eql(current_time.month + 1)
+        expect(next_time.day).to eql(current_time.day)
+        expect(next_time.hour).to eql(current_time.hour)
+        expect(next_time.min).to eql(current_time.min)
+        expect(next_time.sec).to eql(current_time.sec)
+      end
+    end
+
+    context 'by given month and days' do
+      # Since we are running test on 1st month, next month will occur in 31 days
+      time_str = 'P1M31D'
+      let(:time_seconds) { object.time_in_seconds(time_str) }
+      let(:next_time) { current_time + time_seconds }
+      it 'returns expected month' do
+        expect(next_time.year).to eql(current_time.year)
+        expect(next_time.month).to eql(current_time.month + 2)
+        expect(next_time.day).to eql(current_time.day)
+        expect(next_time.hour).to eql(current_time.hour)
+        expect(next_time.min).to eql(current_time.min)
+        expect(next_time.sec).to eql(current_time.sec)
+      end
+    end
+  end
+
+  describe 'Day conversion:' do
+    # Time.now to be a Non-Leap Year(0001-01-01 00:00:00), So that
+    # Tests suites will be independant of their execution Time
+    before(:each) do
+      allow(Time).to receive(:now).and_return(Time.new(1))
+    end
+
+    let(:current_time) { Time.new(1) }
+    context 'on given days' do
+      time_str = 'P1D'
+      let(:time_seconds) { object.time_in_seconds(time_str) }
+      let(:next_time) { current_time + time_seconds }
+      it 'returns expected days' do
+        expect(next_time.year).to eql(current_time.year)
+        expect(next_time.month).to eql(current_time.month)
+        expect(next_time.day).to eql(current_time.day + 1)
+        expect(next_time.hour).to eql(current_time.hour)
+        expect(next_time.min).to eql(current_time.min)
+        expect(next_time.sec).to eql(current_time.sec)
+      end
+    end
+
+    context 'on given hours' do
+      time_str = 'PT24H'
+      let(:time_seconds) { object.time_in_seconds(time_str) }
+      let(:next_time) { current_time + time_seconds }
+      it 'returns expected days' do
+        expect(next_time.year).to eql(current_time.year)
+        expect(next_time.month).to eql(current_time.month)
+        expect(next_time.day).to eql(current_time.day + 1)
+        expect(next_time.hour).to eql(current_time.hour)
+        expect(next_time.min).to eql(current_time.min)
+        expect(next_time.sec).to eql(current_time.sec)
+      end
+    end
+
+    context 'on given minutes' do
+      time_str = 'PT1440M'
+      let(:time_seconds) { object.time_in_seconds(time_str) }
+      let(:next_time) { current_time + time_seconds }
+      it 'returns expected days' do
+        expect(next_time.year).to eql(current_time.year)
+        expect(next_time.month).to eql(current_time.month)
+        expect(next_time.day).to eql(current_time.day + 1)
+        expect(next_time.hour).to eql(current_time.hour)
+        expect(next_time.min).to eql(current_time.min)
+        expect(next_time.sec).to eql(current_time.sec)
+      end
+    end
+
+    context 'on given seconds' do
+      time_str = 'PT86400S'
+      let(:time_seconds) { object.time_in_seconds(time_str) }
+      let(:next_time) { current_time + time_seconds }
+      it 'returns expected days' do
+        expect(next_time.year).to eql(current_time.year)
+        expect(next_time.month).to eql(current_time.month)
+        expect(next_time.day).to eql(current_time.day + 1)
+        expect(next_time.hour).to eql(current_time.hour)
+        expect(next_time.min).to eql(current_time.min)
+        expect(next_time.sec).to eql(current_time.sec)
+      end
+    end
+
+    context 'By the given days, hours, minutes and seconds' do
+      time_str = 'P1DT24H1440M86400S'
+      let(:time_seconds) { object.time_in_seconds(time_str) }
+      let(:next_time) { current_time + time_seconds }
+      it 'returns expected days' do
+        expect(next_time.year).to eql(current_time.year)
+        expect(next_time.month).to eql(current_time.month)
+        expect(next_time.day).to eql(current_time.day + 4)
+        expect(next_time.hour).to eql(current_time.hour)
+        expect(next_time.min).to eql(current_time.min)
+        expect(next_time.sec).to eql(current_time.sec)
+      end
+    end
+  end
+
+  describe 'Minute conversion:' do
+    # Time.now to be a Non-Leap Year(0001-01-01 00:00:00), So that
+    # Tests suites will be independant of their execution Time
+    before(:each) do
+      allow(Time).to receive(:now).and_return(Time.new(1))
+    end
+
+    let(:current_time) { Time.new(1) }
+    context 'on given minute' do
+      time_str = 'PT1M'
+      let(:time_seconds) { object.time_in_seconds(time_str) }
+      let(:next_time) { current_time + time_seconds }
+      it 'returns expected minutes' do
+        expect(next_time.year).to eql(current_time.year)
+        expect(next_time.month).to eql(current_time.month)
+        expect(next_time.day).to eql(current_time.day)
+        expect(next_time.hour).to eql(current_time.hour)
+        expect(next_time.min).to eql(current_time.min + 1)
+        expect(next_time.sec).to eql(current_time.sec)
+      end
+    end
+
+    context 'on given seconds' do
+      time_str = 'PT60S'
+      let(:time_seconds) { object.time_in_seconds(time_str) }
+      let(:next_time) { current_time + time_seconds }
+      it 'returns expected minutes' do
+        expect(next_time.year).to eql(current_time.year)
+        expect(next_time.month).to eql(current_time.month)
+        expect(next_time.day).to eql(current_time.day)
+        expect(next_time.hour).to eql(current_time.hour)
+        expect(next_time.min).to eql(current_time.min + 1)
+        expect(next_time.sec).to eql(current_time.sec)
+      end
+    end
+
+    context 'By given minutes and seconds' do
+      time_str = 'PT1M60S'
+      let(:time_seconds) { object.time_in_seconds(time_str) }
+      let(:next_time) { current_time + time_seconds }
+      it 'returns expected minutes' do
+        expect(next_time.year).to eql(current_time.year)
+        expect(next_time.month).to eql(current_time.month)
+        expect(next_time.day).to eql(current_time.day)
+        expect(next_time.hour).to eql(current_time.hour)
+        expect(next_time.min).to eql(current_time.min + 2)
+        expect(next_time.sec).to eql(current_time.sec)
+      end
+    end
+  end
+
+  describe 'Date-Time conversions:' do
+    # For a single string given in leap/non-leap year
+    time_str = 'P400Y500M600DT700H800M900S'
+
+    context 'In a non leap year' do
+      let(:current_time) { Time.new(1) }
+      let(:time_seconds) { object.time_in_seconds(time_str) }
+      let(:next_time) { current_time + time_seconds }
+      it 'returns expected values' do
+        allow(Time).to receive(:now).and_return(Time.new(1))
+
+        expect(next_time.year).to eql(current_time.year + 443)
+        expect(next_time.month).to eql(current_time.month + 4)
+        expect(next_time.day).to eql(current_time.day + 21)
+        expect(next_time.hour).to eql(current_time.hour + 17)
+        expect(next_time.min).to eql(current_time.min + 35)
+        expect(next_time.sec).to eql(current_time.sec)
+      end
+    end
+
+    context 'In a leap year' do
+      let(:current_time) { Time.new(0) }
+      let(:time_seconds) { object.time_in_seconds(time_str) }
+      let(:next_time) { current_time + time_seconds }
+      it 'returns expected values' do
+        allow(Time).to receive(:now).and_return(Time.new(0))
+
+        # 1 Day less for the same string
+        expect(next_time.year).to eql(current_time.year + 443)
+        expect(next_time.month).to eql(current_time.month + 4)
+        expect(next_time.day).to eql(current_time.day + 20)
+        expect(next_time.hour).to eql(current_time.hour + 17)
+        expect(next_time.min).to eql(current_time.min + 35)
+        expect(next_time.sec).to eql(current_time.sec)
+      end
+    end
+  end
+end