(load "../versions.scm")

(describe "Create versions"
   (context "string->version"
       (context "Full version"     
                (before each:
                        (set! ($ 'version) (string->version "label1.2.3.4extra")))
                (it "recognizes the major version"
                    (expect (version:major ($ 'version)) (be 1)))
                (it "recognizes the minor version"
                    (expect (version:minor ($ 'version)) (be 2)))
                (it "recognizes the micro version"
                    (expect (version:micro ($ 'version)) (be 3)))
                (it "recognizes the patch version"
                    (expect (version:patch ($ 'version)) (be (list 4))))
                (it "recognizes the extra version"
                    (expect (version:extra ($ 'version)) (be "extra"))))
       
       (context "Partial versions"
                (let ((lmfff (string->version "label1.0"))
                      (fmmff (string->version "1.2")))
                (it "recognizes label major and minor"
                    (expect (version:label lmfff) (be "label"))
                    (expect (version:major lmfff) (be 1))
                    (expect (version:minor lmfff) (be 0)))

                (it "recognizes major and minor"
                    (expect (version:label fmmff) (be false))
                    (expect (version:major fmmff) (be 1))
                    (expect (version:minor fmmff) (be 2))
                    (expect (version:micro fmmff) (be false))
                    (expect (version:patch fmmff) (be false)))))

       (context "Invalid versions"
                (it "doesn't recognize label only"
                    (expect (string->version "label") (be false)))
                (it "doesn't recognize major only"
                    (expect (string->version "1") (be false)))))
   
   (context "version->string"
            (let ((version (make-version 1 0 label: "test" micro: 1 patch: (list 1 2) extra: "foo")))
              (it "convertes correctly"
                  (expect (version->string version) (be "test1.0.1.1.2foo"))))))


(describe "Compare versions"
   (context "version=?"
      (it "recognize equal versions if they're exactly the same"
          (let ((v1 (string->version "1.0.1"))
                (v2 (string->version "1.0.1.1")))

            (expect (version=? v1 v1) (be true))
            (expect (version=? v1 v2)  (be false)))))
   
   (context "version<?"
     (it "knows how to compare major versions"
         (let ((v1 (string->version "1.1.2"))
               (v2 (string->version "2.0.0")))
           (expect (version<? v1 v2) (be true))))
     
     (it "knows how to compare minor versions"
         (let ((v1 (string->version "1.1.2"))
               (v2 (string->version "1.3.0")))
           (expect (version<? v1 v2) (be true))))
     
     (it "knows how to compare micro versions"
         (let ((v1 (string->version "1.1.2.3"))
               (v2 (string->version "1.1.2.4")))
           (expect (version<? v1 v2) (be true))))))

(describe "Sort versions")

(describe "Bump versions")