Python 3, 149 bytes

lambda a,*l:shuffle(a)or["That's "+s%(a[0],*map(choice,l))for s in["not my %s, its %s is too %s."]*5+["my %s! Its %s is so %s."]]
from random import*

Try it online!

-9 bytes thanks to movatica

Charcoal, 72 bytes

≔‽θθＦ⁵«That's not my θ, its ‽η is too ‽ζ.⸿»That's my θ! Its ‽η is so ‽ζ.

Try it online! Link is to verbose version of code. Expects the arrays of things, parts and properties to be in the variables θ, η and ζ, which is most easily arranged by providing them in the input rather than the header. Explanation:

≔‽θθ

Pick a random thing.

Ｆ⁵«That's not my θ, its ‽η is too ‽ζ.⸿»

Print five negative sentences.

That's my θ! Its ‽η is so ‽ζ.

Print the positive sentence.

Japt v2.0a0 -R, 73 bytes

ö
6Æ`Tt's `not `pT=Y<5my +`!,`gT 73dT*Hts Vö `tÑ?`ë2!T Wö.

Takes the three lists as U, V, and W. Those are the default input variables anyways, so just put the three lists in the input section.

Try it

ö Saves the random object in variable U
6Æ Range [0..6), and map each to the following string
`That's The string "That's " plus
`not `pT=Y<5 "not " if the index is less than 5 (and store that in variable T), else ""
my Literal "my " plus
+`!,`gT U plus ',' if T, else '!'
73dT*Hts "its " if T, else "Its "
Vö Random item from V
is 
`tsooo`ë2!T "too" if T, else "so"
Wö. Random item from V, plus a period

PowerShell, 147 bytes

This main program will not repeat any part or property in a run, and has reasonable randomization.

$t=$l|Random
$a=$a|Random -c 6
$r=$r|Random -c 6
0..4|%"That's not my $t, its $($a[$_]) is too "+$r[$_]
"That's my $t! Its $($a[5]) is so "+$r[5]

Try it online!

Writing get-random so many times costs so many characters! However, unless you are willing to let parts and properties be repeated, I can't see a way to shrink this in powershell any further. Unless you move the first 3 line pipes to the end of the 3 assignment lines in the header. To have something like

# Header
$l = ("dinosaur", "lamb", "princess", "reindeer", "train")|Get-Random
$a = ("back", "bells", "body", "bows", "crown", "dress", "ears",
 "engine", "fan", "flippers", "funnel", "hooves", "horns", "neck",
 "nose", "roof", "sash", "side", "spines", "spots", "tail", "teeth",
 "tiara", "wheels", "windows")|sortGet-Random
$r = ("bumpy", "fluffy", "furry", "fuzzy", "glittery", "glossy",
 "hairy", "red", "rough", "rusty", "shiny", "silky", "slippery", 
 "soft", "sparkly", "squashy", "thick", "velvety", "woolly")|sortGet-Random

# Main
(1..5)|%echo("That's not my $t, its "+$a[$_]+" is too "+$r[$_])
"That's my $t! Its "+$a[6]+" is so "+$r[6]

But that seems like it's cheating, and still doesn't beat Neil's answer.

Edit: Thanks for the tips Matt, and thanks AdmBorkBork for fleshing them out, removing the 3 sets of get- text reduced it to 159 bytes, then some more golf from Adm got it down to 147. The code I was thinking of which allowed duplicates and contradictory statements was 144 characters after applying the same golf tips.

function n(random 18)+1
$t=$l[(n)%5]
0..4|%"That's not my $t, its $($a[(n)]) is too "+$r[(n)]
"That's my $t! Its $($a[$(n)]) is so "+$r[(n)]

Try it online!

However, it not only has a tendency to say the same thing multiple times, but it pretty much requires that your inputs be the same number of elements. I believe the pseudo random number generator being used is heavily dependent on the clock, and quick repeated calls to it can often result in the same result. Then it has the condition that it only uses the whole list if all lists are the same length.With only saving 3~5 characters and having so many caveats, I prefer the code at the start of this post.

Jelly, 72 bytes

XWWẋ6;X€}⁶pʋ€s5“ʠĖµʋb⁵J¥¢wBD®-Ƥd(CḤ!²kT“Ø!1ẆÑ⁹ṁṾƤṛḄėÄṂMƓṾṖ¿O*½»Ỵ€¤żⱮ"ẎY

Try it online!

JavaScript, 129

(a,b,c)=>(z='',a.forEach((f,i)=>z+=`That's $q=i!=5?"not ":""my $f$q?", i":"! I"ts $b[i] is $q?"to":"s"o $c[i].n`),z)

input is three arrays, returns string

Ruby, 128 bytes

->a,*lt=a.sample;6.times

Try it online!

C#, 204 203 bytes

()=>int a(int x)=>new Random().Next(x);var j=t[a(5)];string s()=>$"That's not my j, its p[a(25)] is too o[a(19)].n";return s()+s()+s()+s()+s()+$"That's my j! Its p[a(25)] is so o[a(19)].";;

It is my first answer on this site, so I hope it works well. It also needs those three things, but according to question those do not count:

 var t = new[] "dinosaur", "lamb", "princess", "reindeer", "train" ;
 var p = new[] "back", "bells", "body", "bows", "crown", "dress", "ears",
 "engine", "fan", "flippers", "funnel", "hooves", "horns", "neck",
 "nose", "roof", "sash", "side", "spines", "spots", "tail", "teeth",
 "tiara", "wheels", "windows" ;
 var o = new[] "bumpy", "fluffy", "furry", "fuzzy", "glittery", "glossy",
 "hairy", "red", "rough", "rusty", "shiny", "silky", "slippery",
 "soft", "sparkly", "squashy", "thick", "velvety", "woolly";

Try it online!

One less byte thanks to Sok.

APL (Dyalog Unicode), 117 bytes^SBCS

↑('That''s not my ',(t←T⊃⍨?5),', its ')∘,¨P[5?25],¨' is too '∘,¨V[5?19]
'That''s my ',t,'! Its',P[?25],'is so',V[?19]

Try it online!

?N generates a random index among the first N indices.

M?N generates M random indices (without replacement) among the first N indices.

, is concatenation

t←T⊃⍨… picks a random thing and calls it t for reuse in the last line.

∘,¨ concatenates the string on the left to each string on the right.

,¨ concatenates each string on the left to each string on the right.

↑ changes the list of strings into a character matrix so it prints right.

Pyth, 88 78 76 bytes

JONj_ms.ic"That's
 my 

ts 
 is 
o 
."b[?d" not"kJ?d", i""! I"OG?ds"to"OH)6

Try it online!

The code presented above requires the following header:

=N["dinosaur""lamb""princess""reindeer""train")=G["back""bells""body""bows""crown""dress""ears""engine""fan""flippers""funnel""hooves""horns""neck""nose""roof""sash""side""spines""spots""tail""teeth""tiara""wheels""windows")=H["bumpy""fluffy""furry""fuzzy""glittery""glossy""hairy""red""rough""rusty""shiny""silky""slippery""soft""sparkly""squashy""thick""velvety""woolly")

There's a small issue with using the 'Header' feature in TIO with Pyth, as it looks like TIO joins the code blocks on newlines, and newlines are significant in Pyth. Here is a link to the same code using the 'Header' block, with a junk line in the output.

JONj_ms.ic"That's¶ my ¶¶ts ¶ is ¶o ¶."b[?d" not"kJ?d", i""! I"OG?d"to"sOH)6 Newlines replaced with ¶
 Implicit: k="", b=newline
 From header: N=things, G=parts, H=properties
JON Choose a random element from N, store in J
 m 6 Map [0-6), as d, using:
 ?d" not"k If d is truthy (i.e. not 0), yield " not", else ""
 J J (the chosen thing)
 ?d", i""! I" ", i" if d else "! I"
 OG Random element from G
 ?d"to"s "to" if d else "s"
 OH Random element from H
 [ ) Wrap the previous 6 results in an array
 c"That's¶ my ¶¶ts ¶ is ¶o ¶."b Split the template string on newlines
 .i Interleave the template string elements with the previous list
 s Concatenate
 _ Reverse lines
 j Join on newlines, implicit print

Edit: Rewrite to golf 10 bytes, previous version: J+" my "ONV5%"That's not%s, its %s is too %s."[JOGOH;%"That's%s! Its %s is so %s."[JOGOH

Perl 5.10, 127 bytes

Run with perl -M5.010 -f filename.pl.

my @t = qw(dinosaur lamb princess reindeer train);
my @r = qw(back bells body bows crown dress ears engine fan flippers funnel
 hooves horns neck nose roof sash side spines spots tail teeth tiara
 wheels windows);
my @p = qw(bumpy fluffy furry fuzzy glittery glossy hairy red rough rusty shiny
 silky slippery soft sparkly squashy thick velvety woolly);

sub rrand@_$a=" my $t[r@t]";say"That's not$a, its $r[r@r] is too $p[r@p]."for(1..5);say"That's$a! Its $r[r@r] is so $p[r@p]."

JavaScript ES6, 149 (+15?) bytes

a = ["dinosaur", "lamb", "princess", "reindeer", "train"]
b = ["back", "bells", "body", "bows", "crown", "dress", "ears",
 "engine", "fan", "flippers", "funnel", "hooves", "horns", "neck",
 "nose", "roof", "sash", "side", "spines", "spots", "tail", "teeth",
 "tiara", "wheels", "windows"]
c = ["bumpy", "fluffy", "furry", "fuzzy", "glittery", "glossy",
 "hairy", "red", "rough", "rusty", "shiny", "silky", "slippery", 
 "soft", "sparkly", "squashy", "thick", "velvety", "woolly"]

// r=x=>x[parseInt(Math.random()*x.length)] 164 for better random on fast pc

r=x=>x[new Date%x.length]
s=r(a)
g=j=>console.log(`That's $j?`not my $s, its $r(b) is to`:`my $s! Its $r(b) is s`o $r(c).`)
a.map(g) 
g()

Batch File, 434 424 + 7 bytes

Executed via cmd/q/c.

Code not counted

set a=dinosaur lamb princess reindeer train
set b=back bells body bows crown dress ears engine fan flippers funnel hoobes horns neck nose roof sash side spines spots tail teeth tiara wheels windows
set c=bumpy fluffy furry fizzy glittery glossy hair red rough rusty shiny silky slippery soft sparkly squashy thick velvety woolly

Code counted

set q=random
set m=set/ar=1+%%%q%%%%%%%
call %m%5
for /f "tokens=%r%" %%x in ("%a%")do set x=%%x
:a
set/ad+=1
call %m%25
for /f "tokens=%r%" %%y in ("%b%")do set y=%%y
call %m%19
for /f "tokens=%r%" %%z in ("%c%")do echo That's not my %x%, its %y% is too %%z.
if %d% neq 5 goto a
call %m%25
for /f "tokens=%r%" %%y in ("%b%")do set y=%%y
call %m%19
for /f "tokens=%r%" %%z in ("%c%")do echo That's my %x%! Its %y% is so %%z.

I'll go through some challenges you must face and explain/justify what I did so others can improve.

Choose a random element from an array

I did this by generating a random number between 1 and n where n is the amount of elements in that array. I then used this random number as the token to grab in each for loop (tokens=%r%). Because I did it this way, I could not nest these for loops anymore, as tokens=!r! was not working for me (with delayed expansion). This would've saved quite a few bytes as it would've removed the need to save the tokens as variables (set x=%%x).

Random number generation
m is my random number generation macro. Doing it this way saves 32 bytes over doing it like set/ar=%random%%%n+1 every line. You could semi-cheat and decide that tokens y and z are to be the same element:

call %m%19
for /f "tokens=%r%" %%y in ("%b%")do set y=%%y
for /f "tokens=%r%" %%z in ("%c%")do echo That's not my %x%, its %y% is too %%z.

This would, while still retaining some randomness, exclude the final 6 elements of c. This would save a minimum of 20 bytes, but I don't think this is true to the op's requirements.

Theoretical Improvements

I spent quite a while trying to make this "pseudo-code" work, while still saving bytes:

set 1-5=echo That's not my %x%, its %y% is too %%z.
set 6=echo That's my %x%! Its %y% is so %%z.
...
set/ad+=1
for /f "tokens=%r%" %%z in ("%c%")do call %%d%%

Unfortunately the setup for this is proving to take up way too many bytes to be profitable (have to implement in < 144 bytes) but I can't shake the feeling that adding the last 4 lines of code are superfluous and janky.

ink, 119 bytes

~a=LIST_RANDOM(a)
-(l)That'sl<6: not my a! Its LIST_RANDOM(b) is l<6:too LIST_RANDOM(c)
l<6:->l

With the lists defined as

LIST a=(dinosaur),(lamb),(princess),(reindeer),(train)
LIST b=(back),(bells),(body),(bows),(crown),(dress),(ears),(engine),(fan),(flippers),(funnel),(hooves),(horns),(neck),(nose),(roof),(sash),(side),(spines),(spots),(tail),(teeth),(tiara),(wheels),(windows)
LIST c=(bumpy),(fluffy),(furry),(fuzzy),(glittery),(glossy),(hairy),(red),(rough),(rusty),(shiny),(silky),(slippery),(soft),(sparkly),(squashy),(thick),(velvety),(woolly)

Try it online!

Though depending on what counts as a list, there are other approaches. If a list can be a function that randomly returns a list item, the following approach is only 91 bytes:

~temp t=u()
-(l)That'sl<6: not my t! Its p() is l<6:too q()
l<6:->l

(with the "lists" defined as follows)

==function u
~return "train"
==function p
~return "spines"
==function q
~return " glittery."

Try it online!

There's also the following approach.

~temp t="train"
-(l)That'sl<6: not my t! Its spines is l<6:too glittery
l<6:->l

Try it online!

This solution is 389 bytes, but if the shuffle literals (which in this scenario can't really be moved) count as list definitions and can be excluded from the byte count, this drops to 80 bytes.

Bash +awk, 209 bytes

T=$(shuf $1|head -1)
join <(sed "s/.*/$Tt&/" $2) <(sed "s/.*/$Tt&/" $3)|shuf|awk 'NR<6printf "That'''s not my %s, its %s is too %s.n",$1,$2,$3NR==6printf "That'''s my %s! Its %s is so %s.n",$1,$2,$3'

Try it online!

Accepts inputs as things parts properties where each is a file with one item per line of the desired type.

This is a file-centered approach. May try an array-centered approach later to see if it can be improved.

Python 3, 130 bytes

Taking your requirements literally, and taking carriage returns to be one byte each:

y=0
def x():
 global y
 y=1-y 
 print(("That's not my lamb, it's "+b[0:1][y]+" is too redn")*5+"That's my lamb! Its fan is so red")