~qbzr-dev/qbzr/mergetools

« back to all changes in this revision

Viewing changes to lib/tests/test_loggraphviz.py

  • Committer: Gary van der Merwe
  • Date: 2010-11-08 23:05:01 UTC
  • mfrom: (1299.1.37 trunk)
  • Revision ID: garyvdm@gmail.com-20101108230501-p99b9msstay5jyl2
Merge Trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
68
68
        computed = gv.compute_viz(state)
69
69
        self.assertEqual(len(computed.revisions), 0)
70
70
 
71
 
    def test_branch_tips_date_sorted(self):
 
71
    def make_banches_for_tips_date_sorted(self):
72
72
        builder = self.make_branch_builder('trunk')
73
73
        builder.start_series()
74
74
        builder.build_snapshot('rev-a', None, [
85
85
        
86
86
        new = trunk.bzrdir.sprout('../new', revision_id='rev-new').open_branch()
87
87
        
 
88
        return trunk, old, new
 
89
 
 
90
    def test_branch_tips_date_sorted(self):
 
91
        trunk, old, new = self.make_banches_for_tips_date_sorted()
 
92
        
88
93
        trunk_bi = loggraphviz.BranchInfo('trunk', None, trunk)
89
94
        gv = loggraphviz.GraphVizLoader(
90
95
            [trunk_bi,
106
111
             ('rev-a', 0, None, [])                                  ],# ○ 
107
112
            computed)
108
113
    
 
114
    def test_branch_tips_date_sorted_with_working_tree_provider(self):
 
115
        trunk, old, new = self.make_banches_for_tips_date_sorted()
 
116
        trunk_tree = trunk.bzrdir.create_workingtree()
 
117
        old_tree = old.bzrdir.open_workingtree()
 
118
        new_tree = new.bzrdir.open_workingtree()
 
119
        
 
120
        trunk_bi = loggraphviz.BranchInfo('trunk', trunk_tree, trunk)
 
121
        gv = loggraphviz.WithWorkingTreeGraphVizLoader(
 
122
            [trunk_bi,
 
123
             loggraphviz.BranchInfo('old', old_tree, old),
 
124
             loggraphviz.BranchInfo('new', new_tree, new),],
 
125
            trunk_bi, False)
 
126
        gv.load()
 
127
        
 
128
        state = loggraphviz.GraphVizFilterState(gv)
 
129
        computed = gv.compute_viz(state)
 
130
        
 
131
        self.assertComputed(
 
132
            [(gv.tree_revid(new_tree), 2, None, [(2, 2, 3, True)]),    #     ○ 
 
133
                                                                       #     │ 
 
134
             ('rev-new', 2, None, [(2, 2, 0, True)]),                  #     ○ 
 
135
                                                                       #     │ 
 
136
             (gv.tree_revid(old_tree), 1, None, [(1, 1, 2, True),      #   ○ │ 
 
137
                                                 (2, 2, 0, True)]),    #   │ │
 
138
             ('rev-old', 1, None, [(1, 1, 0, True), (2, 2, 0, True)]), #   ○ │ 
 
139
                                                                       #   │ │ 
 
140
             (gv.tree_revid(trunk_tree), 0, None, [                    # ○ │ │ 
 
141
                (0, 0, 0, True), (1, 1, 0, True), (2, 2, 0, True)]),   # │ │ │ 
 
142
             ('rev-trunk', 0, None, [(0, 0, 0, True), (1, 0, 0, True), # ○ │ │ 
 
143
                                     (2, 0, 0, True)]),                # ├─╯─╯
 
144
             ('rev-a', 0, None, [])],                                  # ○ 
 
145
            computed)
 
146
 
 
147
    
109
148
    def make_tree_with_pending_merge(self, path):
110
149
        builder = self.make_branch_builder('branch')
111
150
        builder.start_series()
201
240
             ('rev-a', 0, None, [], []) ],                              # ○
202
241
            computed, branch_labels=True)
203
242
 
 
243
    def test_with_working_tree_provider_filtered(self):
 
244
        # This test makes sure that lable for a Working Tree shows for on it's
 
245
        # nearest visble unique ansestor when the working tree node is
 
246
        # filtered. 
 
247
        builder = self.make_branch_builder('branch')
 
248
        builder.start_series()
 
249
        builder.build_snapshot('rev-a', None, [
 
250
            ('add', ('', 'TREE_ROOT', 'directory', '')),])
 
251
        builder.build_snapshot('rev-b', ['rev-a'], [])
 
252
        builder.build_snapshot('rev-c', ['rev-a'], [])
 
253
        builder.finish_series()
 
254
        
 
255
        branch = builder.get_branch()
 
256
        tree = branch.bzrdir.create_workingtree()
 
257
        tree.update(revision='rev-b')
 
258
        
 
259
        bi = loggraphviz.BranchInfo('branch', tree, tree.branch)
 
260
        gv = loggraphviz.WithWorkingTreeGraphVizLoader([bi], bi, False)
 
261
        gv.load()
 
262
        
 
263
        state = loggraphviz.GraphVizFilterState(gv)
 
264
        state.filters.append(BasicFilterer(set([
 
265
            'current:%s' % tree.basedir.encode('unicode-escape')])))
 
266
        computed = gv.compute_viz(state)
 
267
        self.assertComputed(
 
268
            [('rev-b', 1, None, [(1, 1, 0, True)], ['branch - Working Tree'])  , #   ○ 
 
269
                                                                                 #   │ 
 
270
             ('rev-c', 0, None, [(0, 0, 0, True), (1, 0, 0, True)], ['branch']), # ○ │ 
 
271
                                                                                 # ├─╯ 
 
272
             ('rev-a', 0, None, [], [])                                        ],# ○ 
 
273
            computed, branch_labels=True)
 
274
    
204
275
    def test_pending_merges_provider(self):
205
276
        tree = self.make_tree_with_pending_merge('branch')
206
277
        
507
578
         'rev-c': ('rev-a', 'rev-b'),
508
579
         'rev-d': ('rev-a', 'rev-c'),
509
580
        })
 
581
        # d 
 
582
        # ├─╮ 
 
583
        # │ c 
 
584
        # │ ├─╮ 
 
585
        # │ │ b
 
586
        # ├─╯─╯ 
 
587
        # a
510
588
        gv.load()
511
589
        
512
590
        state = loggraphviz.GraphVizFilterState(gv)
520
598
             ('rev-b', 1, None, [(0, 0, 0, True), (1, 0, 0, True)])  , # │ ○ 
521
599
                                                                       # ├─╯ 
522
600
             ('rev-a', 0, None, [])                                  ],# ○ 
523
 
            computed)    
 
601
            computed)
524
602
 
 
603
    def test_merge_line_hidden2(self):
 
604
        gv = BasicGraphVizLoader(('rev-e',), {
 
605
         'rev-a': (NULL_REVISION, ), 
 
606
         'rev-z': ('rev-a', ),
 
607
         'rev-y': ('rev-a', 'rev-z', ),
 
608
         'rev-b': ('rev-a', ),
 
609
         'rev-c': ('rev-a', ),
 
610
         'rev-d': ('rev-a', 'rev-c'),
 
611
         'rev-e': ('rev-y', 'rev-b', 'rev-d'),
 
612
        })
 
613
        # f     
 
614
        # ├─╮─╮ 
 
615
        # │ b │ 
 
616
        # │ │ │ 
 
617
        # │ │ e   
 
618
        # │ │ ├─╮ 
 
619
        # │ │ │ d
 
620
        # ├─╯─╯─╯ 
 
621
        # a
 
622
        gv.load()
 
623
        
 
624
        state = loggraphviz.GraphVizFilterState(gv)
 
625
        #state.expand_all_branch_lines()
 
626
        state.branch_line_state[(1, 1)] = None
 
627
        state.branch_line_state[(1, 2)] = None
 
628
        #state.branch_line_state[(1, 3)] = None
 
629
        state.branch_line_state[(1, 4)] = None
 
630
        
 
631
        computed = gv.compute_viz(state)
 
632
        # when the merge by branch line, we should show a non direct line
 
633
        # this could layout better, but that's another story...
 
634
        self.assertComputed(
 
635
            [('rev-e', 0, False, [(0, 0, 0, True), (0, 1, 3, False), (0, 2, 5, True)])               , # ⊕     
 
636
                                                                                                       # ├┄╮─╮ 
 
637
             ('rev-b', 2, None, [(0, 0, 0, True), (1, 3, 3, False), (2, 2, 0, True)])                , # │ ┆ ○   
 
638
                                                                                                       # │ ╰┄┼┄╮ 
 
639
             ('rev-c', 3, None, [(0, 0, 0, True), (2, 2, 0, True), (3, 3, 0, True)])                 , # │   │ ○ 
 
640
                                                                                                       # │   │ │ 
 
641
             ('rev-y', 0, True, [(0, 0, 0, True), (0, 1, 2, True), (2, 2, 0, True), (3, 3, 0, True)]), # ⊖   │ │ 
 
642
                                                                                                       # ├─╮ │ │ 
 
643
             ('rev-z', 1, None, [(0, 0, 0, True), (1, 0, 0, True), (2, 0, 0, True), (3, 0, 0, True)]), # │ ○ │ │ 
 
644
                                                                                                       # ├─╯─╯─╯ 
 
645
             ('rev-a', 0, None, [])                                                                  ],# ○ 
 
646
            computed)
 
647
    
525
648
    def test_merge_line_hidden_merge_rev_filtered(self):
526
649
        gv = BasicGraphVizLoader(('rev-e',), {
527
650
         'rev-a': (NULL_REVISION, ), 
599
722
             ('rev-a', 0, None, [])                                                  ],# ○
600
723
            computed)
601
724
 
 
725
    def test_no_graph(self):
 
726
        gv = BasicGraphVizLoader(('rev-d',), {
 
727
         'rev-a': (NULL_REVISION, ), 
 
728
         'rev-b': ('rev-a', ),
 
729
         'rev-c': ('rev-a', ),
 
730
         'rev-d': ('rev-b', 'rev-c'),
 
731
        }, no_graph=True)
 
732
        gv.load()
 
733
        
 
734
        state = loggraphviz.GraphVizFilterState(gv)
 
735
        computed = gv.compute_viz(state)
 
736
        self.assertComputed(
 
737
            [('rev-d', 0.0, None, []), # ○ 
 
738
                                       #   
 
739
             ('rev-c', 0.5, None, []), #  ○ 
 
740
                                       #    
 
741
             ('rev-b', 0.0, None, []), # ○ 
 
742
                                       #   
 
743
             ('rev-a', 0.0, None, [])],# ○ 
 
744
            computed)
 
745
    
 
746
    def test_no_graph_filtered(self):
 
747
        gv = BasicGraphVizLoader(('rev-d',), {
 
748
         'rev-a': (NULL_REVISION, ), 
 
749
         'rev-b': ('rev-a', ),
 
750
         'rev-c': ('rev-a', ),
 
751
         'rev-d': ('rev-b', 'rev-c'),
 
752
        }, no_graph=True)
 
753
        gv.load()
 
754
        
 
755
        state = loggraphviz.GraphVizFilterState(gv)
 
756
        state.filters.append(BasicFilterer(set(['rev-b'])))
 
757
        computed = gv.compute_viz(state)
 
758
        self.assertComputed(
 
759
            [('rev-d', 0.0, None, []), # ○ 
 
760
                                       #   
 
761
             ('rev-c', 0.5, None, []), #  ○ 
 
762
                                       # 
 
763
             ('rev-a', 0.0, None, [])],# ○ 
 
764
            computed)
602
765
 
603
766
class TestLogGraphProviderState(TestCase):
604
767
 
820
983
        self.filtered_revids = filtered_revids
821
984
    
822
985
    def get_revision_visible(self, rev):
823
 
         return rev.revid not in self.filtered_revids
 
986
        return rev.revid not in self.filtered_revids
824
987
 
825
988
def print_computed(computed):
826
989
    print_lines([(c_rev.rev.revid,
926
1089
        next_line = [' ' for i in range(num_cols)]
927
1090
        
928
1091
        for start, end, color, direct in lines:
 
1092
            if start is None or end is None:
 
1093
                continue
929
1094
            start = int(round(start))
930
1095
            end = int(round(end))
931
1096
            if start == end:
940
1105
                line[i] = char_dict[old_char]
941
1106
            
942
1107
        for start, end, color, direct in lines:
 
1108
            if start is None or end is None:
 
1109
                continue
943
1110
            start = int(round(start))
944
1111
            end = int(round(end))
945
1112
            if start < end: