tSQLt Message de réponse tronqué AssertResultSetsHaveSameMetaData dans SQLTest

Question

J'essaie d'utiliser tSQLt AssertResultSetsHaveSameMetaData pour vérifier les métadonnées d'une requête qui renvoie un grand nombre de colonnes.

Quand il échoue, le message qui détaille le « prévu/mais était » détails est tronquée, donc je ne peux pas les deux informations pour voir ce qui est faux. Existe-t-il un moyen de générer le message afin qu'il ne soit pas tronqué (par exemple, dans un fichier)?

Answer 1

Vous pouvez essayer EXEC [tSQLt].[XmlResultFormatter]; avant de lancer votre test. Ceci est destiné à être utilisé dans des scénarios de "build server", mais pourrait probablement être mis en service pour vous montrer plus de la sortie dans SSMS.

Answer 2

Cela dépend de ce que vous êtes en train de tester. Je suis d'accord que sur les ensembles de résultats larges, la sortie de AssertResultsSetsHaveSameMetaData peut être un peu compliquée. Pour les procédures stockées vous écrivez vos tests comme ceci:

 
create procedure [ProcedureTests].[test SelectProcedure result set contract] 
as 
begin 
    create table #expected 
    (
     name varchar(500) not null 
    , column_ordinal int not null identity(1,1) 
    , system_type_name varchar(500) not null 
    , Nullability varchar(16) not null 
    ) 

    ; with expectedCte (name, system_type_name, Nullability) 
    as 
    (
        select 'ItemId'       , 'int'    , 'not null' 
     union all select 'ActorId'       , 'int'    , 'not null' 
     union all select 'LanId'       , 'nvarchar(200)' , 'not null' 
     union all select 'ConsumerId'      , 'int'    , 'not null' 
     union all select 'ConsumerMoniker'     , 'nvarchar(200)' , 'not null' 
     union all select 'ProfileTypeId'     , 'int'    , 'not null' 
     union all select 'ProfileTypeName'     , 'varchar(50)'  , 'not null' 
     union all select 'ProfileId'      , 'int'    , 'not null' 
    ) 
    insert #expected 
    (
     name 
    , system_type_name 
    , Nullability 
    ) 
    select name, system_type_name, Nullability from expectedCte; 

    --! Act 
    select 
      name 
     , column_ordinal 
     , system_type_name 
     , case is_nullable when 1 then 'null' else 'not null' end as [Nullability] 
    into 
     #actual 
    from 
     sys.dm_exec_describe_first_result_set_for_object(object_id('mySchema.SelectProcedure'), 0); 

    --! Assert 
    exec tSQLt.AssertEqualsTable #expected, #actual; 
end; 
go 

Alors que pour les vues, vous pouvez utiliser cette approche (légèrement différente):

 
alter procedure [ViewTests].[test ViewName resultset contract] 
as 
begin 
    create table [ViewTests].[expected] 
    (
     TransactionId int not null 
    , SourceId int not null 
    , SourceKey nvarchar(50) not null 
    , TransactionTypeId int not null 
    , TransactionStatusId int not null 
    , LastModified datetime not null 
    ); 
    --! You comparison may be as simple as this (but see alternative approach below) 
    exec tSQLt.AssertEqualsTableSchema '[ViewTests].[expected]', 'mySchema.ViewName'; 


    --! 
    --! Seems that is_nullable column on dm_exec_describe_first_result_set (used by tSQLt.AssertEqualsTableSchema) 
    --! can be a bit flakey where views are concerned so you may need to ignore nullability when testing 
    --! this view (so comment out that column in both SELECTs) 
    --! 
    select 
      c.name as [ColumnName] 
     , c.column_id as [ColumnPosition] 
     , case 
      when st.name in ('char', 'varchar', 'varbinary') 
       then st.name + '(' + case when c.max_length = -1 then 'max' else coalesce(cast(c.max_length as varchar(8)), '???') end + ')' 
      when st.name in ('nchar', 'nvarchar') 
       then st.name + '(' + case when c.max_length = -1 then 'max' else coalesce(cast(c.max_length/2 as varchar(8)), '???') end + ')' 
      when st.name in ('decimal', 'numeric') 
       then st.name + '(' + coalesce(cast(c.precision as varchar(8)), '???') + ',' + coalesce(cast(c.scale as varchar(8)), '???') + ')' 
      when st.name in ('time', 'datetime2', 'datetimeoffset') 
       then st.name + '(' + coalesce(cast(c.precision as varchar(8)), '???') + ')' 
      else st.name 
      end as [DataType] 
     , c.[precision] as [NumericScale] 
     , c.scale as [NumericPrecision] 
     , c.collation_name as [CollationName] 
     , cast(case c.is_nullable when 1 then 'null' else 'not null' end as varchar(16)) as [Nullability] 
    into 
     #expected 
    from 
     sys.columns as c 
    inner join sys.types as st 
     on st.system_type_id = c.system_type_id 
     and st.user_type_id = c.user_type_id 
    where 
     c.[object_id] = object_id('[ViewTests].[expected]') 

    select 
      name as [ColumnName] 
     , column_ordinal as [ColumnPosition] 
     , system_type_name as [DataType] 
     , [precision ]as [NumericScale] 
     , scale as [NumericPrecision] 
     , collation_name as [CollationName] 
     , cast(case is_nullable when 1 then 'null' else 'not null' end as varchar(16)) as [Nullability] 
    into 
     #actual 
    from 
     sys.dm_exec_describe_first_result_set('select * from mySchema.ViewName, null, null) 

    exec tSQLt.AssertEqualsTable '#expected', '#actual' ; 
end 
go 

Dans le même de toute défaillance, la raison sera beaucoup plus clair car la sortie ressemble plus à AssertEqualsTable.